pipeSafely to pipe streams in such a way that
-
+
@@ -1789,7 +1789,7 @@ Similarly, we have a pipeSafely to pipe streams in such a way that
-
+
@@ -1800,7 +1800,7 @@ Similarly, we have a pipeSafely to pipe streams in such a way that
-
+
@@ -1811,7 +1811,7 @@ Similarly, we have a pipeSafely to pipe streams in such a way that
-
+
AuthorizingHttpHandle
-
+
@@ -1812,7 +1812,7 @@ one of which has no identifier but is an instance of AuthorizingHttpHandle
-
+
@@ -1823,7 +1823,7 @@ one of which has no identifier but is an instance of AuthorizingHttpHandle
-
+
@@ -1834,7 +1834,7 @@ one of which has no identifier but is an instance of AuthorizingHttpHandle
-
+
Class AbsolutePathInteractionRoute
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Absolute Path Interaction Route(path, ensureSlash?): AbsolutePathInteractionRoute Parameters
- path: string
- ensureSlash: boolean = true
Returns AbsolutePathInteractionRoute
Methods
get
match
- match
Path(path): undefined | EmptyObject Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | EmptyObject
- path: string
Class AcceptPreferenceParser
Extracts preferences from the Accept-* headers from an incoming HttpRequest. -Supports Accept, Accept-Charset, Accept-Encoding, Accept-Language and Accept-DateTime.
-Hierarchy (view full)
- PreferenceParser
- AcceptPreferenceParser
Index
Constructors
Methods
Constructors
constructor
- new
Accept Preference Parser(): AcceptPreferenceParser Returns AcceptPreferenceParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<RepresentationPreferences>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<RepresentationPreferences> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class AccessCheckerAbstract
Performs an authorization check against the given acl resource.
-Hierarchy (view full)
- AsyncHandler<AccessCheckerArgs, boolean>
Index
Constructors
Methods
Constructors
constructor
- new
Access Checker(): AccessChecker Returns AccessChecker
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AccessCheckerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
Abstracthandle
- handle(input): Promise<boolean>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AccessCheckerArgs
Input that needs to be handled.
-
Returns Promise<boolean>
A promise resolving when handling is finished.
-- input: AccessCheckerArgs
handle
- handle
Safe(input): Promise<boolean> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AccessCheckerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<boolean>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
Class AccountInitializer
Initializes an account with email/password login and a pod with the provided name.
-Hierarchy (view full)
- Initializer
- AccountInitializer
Index
Constructors
constructor
- new
Account Initializer(args): AccountInitializer Parameters
- args: AccountInitializerArgs
Returns AccountInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class AccountPromptFactory
Creates the prompt necessary to ensure a user is logged in with their account when doing an OIDC interaction. -This is done by checking the presence of the account-related cookie.
-Adds a Check to the login policy that verifies if the stored accountId, which corresponds to the chosen WebID, -belongs to the currently logged in account.
-Hierarchy (view full)
- PromptFactory
- AccountPromptFactory
Index
Constructors
constructor
- new
Account Prompt Factory(webIdStore, cookieStore, cookieName): AccountPromptFactory Parameters
- webIdStore: WebIdStore
- cookieStore: CookieStore
- cookieName: string
Returns AccountPromptFactory
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: DefaultPolicy
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: DefaultPolicy
handle
- handle(policy): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- policy: DefaultPolicy
Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: DefaultPolicy
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: DefaultPolicy
Class AcpHeaderHandler
Handles all the required ACP headers as defined at -https://solid.github.io/authorization-panel/acp-specification/#conforming-acp-server
-Hierarchy (view full)
- HttpHandler
- AcpHeaderHandler
Index
Constructors
Methods
Constructors
constructor
- new
Acp Header Handler(targetExtractor, strategy, modes, attributes): AcpHeaderHandler Parameters
- targetExtractor: TargetExtractor
- strategy: AuxiliaryIdentifierStrategy
- modes: string[]
- attributes: string[]
Returns AcpHeaderHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class AcpReader
Finds the permissions of a resource as defined in the corresponding ACRs. -Implementation based on https://solid.github.io/authorization-panel/acp-specification/.
-Caches data so no duplicate calls are made to the ResourceStore for a single request.
-Hierarchy (view full)
- PermissionReader
- AcpReader
Index
Constructors
constructor
- new
Acp Reader(acrStrategy, acrStore, identifierStrategy): AcpReader Parameters
- acrStrategy: AuxiliaryStrategy
- acrStore: ResourceStore
- identifierStrategy: IdentifierStrategy
Returns AcpReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class ActivityNotificationGenerator
A NotificationGenerator that creates a Notification by using the provided activity as type. -Requests metadata of the topic from the ResourceStore to fill in the details.
-Hierarchy (view full)
- NotificationGenerator
- ActivityNotificationGenerator
Index
Constructors
Methods
Constructors
constructor
- new
Activity Notification Generator(store, eTagHandler): ActivityNotificationGenerator Parameters
- store: ResourceStore
- eTagHandler: ETagHandler
Returns ActivityNotificationGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<Notification>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<Notification>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<Notification> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Notification>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class AddRemoveNotificationGenerator
A NotificationGenerator specifically for Add/Remove notifications.
-Creates the notification so the target is set to input topic,
-and the object value is extracted from the provided metadata.
Hierarchy (view full)
- NotificationGenerator
- AddRemoveNotificationGenerator
Index
Constructors
Methods
Constructors
constructor
- new
Add Remove Notification Generator(store, eTagHandler): AddRemoveNotificationGenerator Parameters
- store: ResourceStore
- eTagHandler: ETagHandler
Returns AddRemoveNotificationGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<Notification>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<Notification>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<Notification> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Notification>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class AgentAccessChecker
Checks if the given WebID has been given access.
-Hierarchy (view full)
- AccessChecker
- AgentAccessChecker
Index
Constructors
Methods
Constructors
constructor
- new
Agent Access Checker(): AgentAccessChecker Returns AgentAccessChecker
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AccessCheckerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
handle
- handle(input): Promise<boolean>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AccessCheckerArgs
Input that needs to be handled.
-
Returns Promise<boolean>
A promise resolving when handling is finished.
-- input: AccessCheckerArgs
handle
- handle
Safe(input): Promise<boolean> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AccessCheckerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<boolean>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
Class AgentClassAccessChecker
Checks access based on the agent class.
-Hierarchy (view full)
- AccessChecker
- AgentClassAccessChecker
Index
Constructors
Methods
Constructors
constructor
- new
Agent Class Access Checker(): AgentClassAccessChecker Returns AgentClassAccessChecker
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AccessCheckerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
handle
- handle(input): Promise<boolean>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AccessCheckerArgs
Input that needs to be handled.
-
Returns Promise<boolean>
A promise resolving when handling is finished.
-- input: AccessCheckerArgs
handle
- handle
Safe(input): Promise<boolean> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AccessCheckerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<boolean>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
Class AgentGroupAccessChecker
Checks if the given WebID belongs to a group that has access. -Implements the behaviour of groups from the WAC specification.
-Hierarchy (view full)
- AccessChecker
- AgentGroupAccessChecker
Index
Constructors
Methods
Constructors
constructor
- new
Agent Group Access Checker(): AgentGroupAccessChecker Returns AgentGroupAccessChecker
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AccessCheckerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
handle
- handle(input): Promise<boolean>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AccessCheckerArgs
Input that needs to be handled.
-
Returns Promise<boolean>
A promise resolving when handling is finished.
-- input: AccessCheckerArgs
handle
- handle
Safe(input): Promise<boolean> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AccessCheckerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<boolean>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AccessCheckerArgs
Class AllStaticReader
PermissionReader which sets all permissions to true or false -independently of the identifier and requested permissions.
-Hierarchy (view full)
- PermissionReader
- AllStaticReader
Index
Constructors
Methods
Constructors
constructor
- new
All Static Reader(allow): AllStaticReader Parameters
- allow: boolean
Returns AllStaticReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class AllowAcceptHeaderWriter
Generates Allow, Accept-Patch, Accept-Post, and Accept-Put headers. -The resulting values depend on the choses input methods and types. -The input metadata also gets used to remove methods from that list -if they are not valid in the given situation.
-Hierarchy (view full)
- MetadataWriter
- AllowAcceptHeaderWriter
Index
Constructors
Methods
Constructors
constructor
- new
Allow Accept Header Writer(supportedMethods, acceptTypes): AllowAcceptHeaderWriter Parameters
- supportedMethods: string[]
- acceptTypes: {
patch?: string[];
post?: string[];
put?: string[];
}Optionalpatch?: string[]Optionalpost?: string[]Optionalput?: string[]
Returns AllowAcceptHeaderWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class App
Entry point for the entire Solid server.
- Index
Constructors
constructor
- new
App(initializer, finalizer, clusterManager): App Parameters
- initializer: Initializer
- finalizer: Finalizer
- clusterManager: ClusterManager
Returns App
Class AppRunner
A class that can be used to instantiate and start a server based on a Component.js configuration.
- Index
Constructors
Methods
Methods
create
- create(input?): Promise<App>
Returns an App object, created with the given config, that can start and stop the Solid server.
-Parameters
- input: AppRunnerInput = {}
All values necessary to configure the server.
-
Returns Promise<App>
- input: AppRunnerInput = {}
create
create
get
run
- run(input): Promise<void>
Starts the server with a given config.
-Parameters
- input: AppRunnerInput
All values necessary to configure the server.
-
Returns Promise<void>
- input: AppRunnerInput
run
run
- run
Cli Sync(argv): void Starts the server as a command-line application. -Will exit the process on failure.
-Made non-async to lower the risk of unhandled promise rejections. -This is only relevant when this is used to start as a Node.js application on its own, -if you use this as part of your code you probably want to use the async version.
-Parameters
- argv: {
argv?: CliArgv;
stderr?: WriteStream;
}Input parameters.
-Optionalargv?: CliArgvCommand line arguments.
-Optionalstderr?: WriteStreamStream that should be used to output errors before the logger is enabled.
-
Returns void
- argv: {
Class ArrayUnionHandler<T>
A utility handler that concatenates the results of all its handlers into a single result.
-Type Parameters
- T extends AsyncHandler<unknown, unknown[]>
Hierarchy (view full)
- UnionHandler<T>
- ArrayUnionHandler
Index
Constructors
constructor
- new
Array Union Handler<T>(handlers, requireAll?, ignoreErrors?): ArrayUnionHandler<T> Type Parameters
- T extends AsyncHandler<unknown, unknown[]>
Parameters
- handlers: T[]
OptionalrequireAll: booleanOptionalignoreErrors: boolean
Returns ArrayUnionHandler<T>
Methods
Protectedall
- all
Can Handle(input): Promise<void> Checks if all handlers can handle the input. -If not, throw an error based on the errors of the failed handlers.
-Parameters
- input: AsyncHandlerInput<T>
Returns Promise<void>
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AsyncHandlerInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Protectedcombine
- combine(results): Promise<AsyncHandlerOutput<T>>
Combines the results of the handlers into a single output.
-Parameters
- results: AsyncHandlerOutput<T>[]
Returns Promise<AsyncHandlerOutput<T>>
handle
- handle(input): Promise<Awaited<ReturnType<T["handle"]>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AsyncHandlerInput<T>
Input that needs to be handled.
-
Returns Promise<Awaited<ReturnType<T["handle"]>>>
A promise resolving when handling is finished.
-- input: AsyncHandlerInput<T>
handle
- handle
Safe(input): Promise<Awaited<ReturnType<T["handle"]>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AsyncHandlerInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<Awaited<ReturnType<T["handle"]>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Class AssetPathExtractor
A ShorthandExtractor that converts a path value to an absolute asset path
-by making use of resolveAssetPath.
-Returns the default path in case it is defined and no path was found in the map.
Hierarchy (view full)
- ShorthandExtractor
- AssetPathExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Asset Path Extractor(key, defaultPath?): AssetPathExtractor Parameters
- key: string
OptionaldefaultPath: string
Returns AssetPathExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
handle
- handle(args): Promise<unknown>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- args: Shorthand
Returns Promise<unknown>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<unknown> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<unknown>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class AsyncHandler<TIn, TOut>Abstract
Simple interface for classes that can potentially handle a specific kind of data asynchronously.
-Type Parameters
Hierarchy (view full)
- AsyncHandler
- CredentialsExtractor
- AccessChecker
- ModesExtractor
- Authorizer
- PermissionReader
- MetadataGenerator
- Validator
- BodyParser
- ConditionsParser
- TargetExtractor
- MetadataParser
- PreferenceParser
- RequestParser
- OperationHandler
- ErrorHandler
- MetadataWriter
- ResponseWriter
- PromptFactory
- EmailSender
- PodCreator
- InteractionHandler
- JsonInteractionHandler
- OwnershipValidator
- Finalizer
- CliExtractor
- ShorthandExtractor
- ShorthandResolver
- Initializer
- VariableHandler
- HttpHandler
- OperationHttpHandler
- ServerConfigurator
- WebSocketHandler
- StorageDescriber
- NotificationGenerator
- NotificationSerializer
- WebSocket2023Handler
- StreamingHttp2023Emitter
- NotificationEmitter
- NotificationHandler
- StateHandler
- BaseRouterHandler
- RepresentationConverter
- PatchHandler
- RdfStorePatcher
- RepresentationPatcher
- RouterRule
- BooleanHandler
- CachedHandler
- ConditionalHandler
- MethodFilterHandler
- ParallelHandler
- ProcessHandler
- SequenceHandler
- StaticHandler
- StaticThrowHandler
- UnionHandler
- UnsupportedAsyncHandler
- TemplateEngine
Implemented by
Index
Constructors
Methods
Constructors
constructor
- new
Async Handler<TIn, TOut>(): AsyncHandler<TIn, TOut> Type Parameters
Returns AsyncHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Abstracthandle
- handle(input): Promise<TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class AtomicFileDataAccessor
AtomicDataAccessor that uses the file system to store documents as files and containers as folders. -Data will first be written to a temporary location and only if no errors occur -will the data be written to the desired location.
-Hierarchy (view full)
- FileDataAccessor
- AtomicFileDataAccessor
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Atomic File Data Accessor(resourceMapper, rootFilePath, tempFilePath): AtomicFileDataAccessor Parameters
- resourceMapper: FileIdentifierMapper
- rootFilePath: string
- tempFilePath: string
Returns AtomicFileDataAccessor
Methods
can
- can
Handle(representation): Promise<void> Only binary data can be directly stored as files so will error on non-binary data.
-Parameters
- representation: Representation
Returns Promise<void>
delete
- delete
Resource(identifier): Promise<void> Removes the corresponding file/folder (and metadata file).
-Parameters
- identifier: ResourceIdentifier
Returns Promise<void>
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Will return data stream directly to the file corresponding to the resource. -Will throw NotFoundHttpError if the input is a container.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<Guarded<Readable>>
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Will return corresponding metadata by reading the metadata file (if it exists) -and adding file system specific metadata elements.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<RepresentationMetadata>
Protectedget
Protectedverify
- verify
Existing Extension(link): Promise<void> Verifies if there already is a file corresponding to the given resource. -If yes, that file is removed if it does not match the path given in the input ResourceLink. -This can happen if the content-type differs from the one that was stored.
-Parameters
- link: ResourceLink
ResourceLink corresponding to the new resource data.
-
Returns Promise<void>
- link: ResourceLink
write
- write
Container(identifier, metadata): Promise<void> Creates corresponding folder if necessary and writes metadata to metadata file if necessary.
-Parameters
- identifier: ResourceIdentifier
- metadata: RepresentationMetadata
Returns Promise<void>
Protectedwrite
write
- write
Document(identifier, data, metadata): Promise<void> Writes the given data as a file (and potential metadata as additional file). -Data will first be written to a temporary file and if no errors occur only then the -file will be moved to desired destination. -If the stream errors it is made sure the temporary file will be deleted. -The metadata file will only be written if the data was written successfully.
-Parameters
- identifier: ResourceIdentifier
- data: Guarded<Readable>
- metadata: RepresentationMetadata
Returns Promise<void>
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Protectedwrite
- write
Metadata File(link, metadata): Promise<boolean> Writes the metadata of the resource to a meta file.
-Parameters
- link: ResourceLink
Path related metadata of the resource.
- - metadata: RepresentationMetadata
Metadata to write.
-
Returns Promise<boolean>
True if data was written to a file.
-- link: ResourceLink
Class AuthAuxiliaryReader
Determines the permission for authorization resources (such as ACL or ACR). -In contrast to the regular resource mechanism, read/write access to authorization resources -is obtained by setting Control permissions on the corresponding subject resource -rather than directly setting permissions for the authorization resource itself. -Hence, this class transforms Control permissions on the subject resource -to Read/Write permissions on the authorization resource.
-Hierarchy (view full)
- PermissionReader
- AuthAuxiliaryReader
Index
Constructors
constructor
- new
Auth Auxiliary Reader(reader, authStrategy): AuthAuxiliaryReader Parameters
- reader: PermissionReader
- authStrategy: AuxiliaryStrategy
Returns AuthAuxiliaryReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Protectedinterpret
- interpret
Control(identifier, permissionSet?): Partial<Record<AccessMode, boolean>> Updates the permissions for an authorization resource -by interpreting the Control access mode as allowing full access.
-Parameters
- identifier: ResourceIdentifier
- permissionSet: AclPermissionSet = {}
Returns Partial<Record<AccessMode, boolean>>
Class AuthorizationParser
Parses specific authorization schemes and stores their value as metadata.
-The keys of the input authMap should be the schemes,
-and the values the corresponding predicate that should be used to store the value in the metadata.
-The scheme will be sliced off the value, after which it is used as the object in the metadata triple.
This should be used for custom authorization schemes, -for things like OIDC tokens a CredentialsExtractor should be used.
-Hierarchy (view full)
- MetadataParser
- AuthorizationParser
Index
Constructors
Methods
Constructors
constructor
- new
Authorization Parser(authMap): AuthorizationParser Parameters
- authMap: Record<string, string>
Returns AuthorizationParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class AuthorizedRouteHandler
An InteractionRouteHandler specifically for an AccountIdRoute. -If there is no account ID, implying the user is not logged in, -an UnauthorizedHttpError will be thrown. -If there is an account ID, but it does not match the one in target resource, -a ForbiddenHttpError will be thrown.
-Hierarchy (view full)
- InteractionRouteHandler<AccountIdRoute>
- AuthorizedRouteHandler
Index
Constructors
constructor
- new
Authorized Route Handler(route, source): AuthorizedRouteHandler Parameters
- route: AccountIdRoute
- source: JsonInteractionHandler<Dict<Json>>
Returns AuthorizedRouteHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class AuthorizerAbstract
Verifies whether the credentials provide access with the given permissions on the resource. -An Error with the necessary explanation will be thrown if permissions are not granted.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Authorizer(): Authorizer Returns Authorizer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AuthorizerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AuthorizerInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AuthorizerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: AuthorizerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AuthorizerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AuthorizerInput
Class AuthorizingHttpHandler
Handles all the necessary steps for an authorization. -Errors if authorization fails, otherwise passes the parameter to the operationHandler handler. -The following steps are executed:
--
-
- Extracting credentials from the request. -
- Extracting the required permissions. -
- Reading the allowed permissions for the credentials. -
- Validating if this operation is allowed. -
Hierarchy (view full)
- OperationHttpHandler
- AuthorizingHttpHandler
Index
Constructors
Methods
Constructors
constructor
- new
Authorizing Http Handler(args): AuthorizingHttpHandler Parameters
Returns AuthorizingHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class AuxiliaryLinkMetadataWriter
A MetadataWriter that takes a specific auxiliaryStrategy and relation type as input and -creates a Link header with the strategy identifier and the relation type as "rel" value.
-Hierarchy (view full)
- MetadataWriter
- AuxiliaryLinkMetadataWriter
Index
Constructors
constructor
- new
Auxiliary Link Metadata Writer(auxiliaryStrategy, specificStrategy, relationType): AuxiliaryLinkMetadataWriter Parameters
- auxiliaryStrategy: AuxiliaryStrategy
The strategy used to check if an identifier is any kind of auxiliary identifier.
- - specificStrategy: AuxiliaryStrategy
The strategy used to create a specific kind of auxiliary identifier.
- - relationType: string
The value used to create the "rel" value of the Link header.
-
Returns AuxiliaryLinkMetadataWriter
- auxiliaryStrategy: AuxiliaryStrategy
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class AuxiliaryReader
Determines the permissions of auxiliary resources by finding those of the corresponding subject resources.
-Hierarchy (view full)
- PermissionReader
- AuxiliaryReader
Index
Constructors
constructor
- new
Auxiliary Reader(reader, auxiliaryStrategy): AuxiliaryReader Parameters
- reader: PermissionReader
- auxiliaryStrategy: AuxiliaryStrategy
Returns AuxiliaryReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class BadRequestHttpError
An error thrown when incoming data is not supported. -Probably because an AsyncHandler returns false on the canHandle call.
-Hierarchy
- BaseHttpError
- BadRequestHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Bad Request Http Error(message?, options?): BadRequestHttpError Default message is 'The given input is not supported by the server configuration.'.
-Parameters
Optionalmessage: stringOptional, more specific, message.
-Optionaloptions: HttpErrorOptionsOptional error options.
-
Returns BadRequestHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class Base64EncodingStorage<T>
Encodes the input key with base64 encoding, -to make sure there are no invalid or special path characters.
-Type Parameters
Hierarchy (view full)
- PassthroughKeyValueStorage<T>
- Base64EncodingStorage
Index
Constructors
constructor
- new
Base64 Encoding Storage<T>(source): Base64EncodingStorage<T> Type Parameters
Parameters
- source: KeyValueStorage<string, T>
Returns Base64EncodingStorage<T>
Methods
delete
entries
get
has
set
- set(key, value): Promise<Base64EncodingStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: T
Value to store.
-
Returns Promise<Base64EncodingStorage<T>>
The storage.
-- key: string
Protectedto
Protectedto
Class BaseAccountIdRoute
Implementation of an AccountIdRoute that adds the identifier relative to a base InteractionRoute.
-Hierarchy (view full)
- IdInteractionRoute<never, AccountIdKey>
- BaseAccountIdRoute
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Account Id Route(base): BaseAccountIdRoute Parameters
- base: InteractionRoute<never>
Returns BaseAccountIdRoute
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<"accountId", string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<"accountId", string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<"accountId", string>
- path: string
Class BaseAccountStore
A AccountStore that uses an AccountLoginStorage to keep track of the accounts. -Needs to be initialized before it can be used.
-Hierarchy (view full)
- Initializer
- BaseAccountStore
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Account Store(storage): BaseAccountStore Parameters
- storage: AccountLoginStorage<Record<string, never>>
Returns BaseAccountStore
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
create
- create(): Promise<string>
Creates a new and empty account. -Since this account will not yet have a login method, -implementations should restrict what is possible with this account, -and should potentially have something in place to clean these accounts up if they are unused.
-Returns Promise<string>
get
- get
Setting<T>(id, setting): Promise<AccountSettings[T]> Finds the setting of the account with the given identifier.
-Type Parameters
Parameters
- id: string
The account identifier.
- - setting: T
The setting to find the value of.
-
Returns Promise<AccountSettings[T]>
- id: string
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
update
- update
Setting<T>(id, setting, value): Promise<void> Updates the settings for the account with the given identifier to the new values.
-Type Parameters
Parameters
- id: string
The account identifier.
- - setting: T
The setting to update.
- - value: AccountSettings[T]
The new value for the setting.
-
Returns Promise<void>
- id: string
Class BaseChannelTypeAbstract
A NotificationChannelType that handles the base case of parsing and serializing a notification channel.
-Note that the extractModes call always requires Read permissions on the target resource.
Uses SHACL to validate the incoming data in initChannel.
-Classes extending this can pass extra SHACL properties in the constructor to extend the validation check.
The completeChannel implementation is an empty function.
Hierarchy (view full)
- BaseChannelType
Implements
Index
Constructors
Properties
Methods
Constructors
Protectedconstructor
- new
Base Channel Type(type, route, features?, additionalShaclProperties?): BaseChannelType Parameters
- type: NamedNode<string>
The URI of the notification channel type. -This will be added to the SHACL shape to validate incoming subscription data.
- - route: InteractionRoute<never>
The route corresponding to the URL of the subscription service of this channel type. -Channel identifiers will be generated by appending a value to this URL.
- - features: string[] = DEFAULT_NOTIFICATION_FEATURES
The features that should be enabled for this channel type. -Values are expected to be full URIs, but the
-notify:prefix can also be used. - additionalShaclProperties: unknown[] = []
Any additional properties that need to be added to the default SHACL shape.
-
Returns BaseChannelType
- type: NamedNode<string>
Properties
Protected Readonlyfeatures
Protected Readonlypath
Protected Readonlyshacl
Protected Optionalshacl
Protected Readonlytype
Methods
complete
- complete
Channel(channel): Promise<void> This function will be called after the serialized channel is sent back as a response, -allowing for any final actions that need to happen.
-Parameters
- channel: NotificationChannel
The notification channel that is completed.
-
Returns Promise<void>
- channel: NotificationChannel
extract
- extract
Modes(channel): Promise<AccessMap> Determines which modes are required to allow the given notification channel.
-Parameters
- channel: NotificationChannel
The notification channel to verify.
-
Returns Promise<AccessMap>
The required modes.
-- channel: NotificationChannel
get
- get
Description(): SubscriptionService Returns the SubscriptionService that describes how to subscribe to this channel type.
-Returns SubscriptionService
Protectedget
init
- init
Channel(data, credentials): Promise<NotificationChannel> Initiates the channel by first calling validateSubscription followed by quadsToChannel. -Subclasses can override either function safely to impact the result of the function.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
- credentials: Credentials
Returns Promise<NotificationChannel>
Protectedquads
- quads
To Channel(data, subject): Promise<NotificationChannel> Converts a set of quads to a NotificationChannel. -Assumes the data is valid, so this should be called after validateSubscription.
-The generated identifier will be a URL made by combining the base URL of the channel type with a unique identifier.
-The values of the default features will be added to the resulting channel, -subclasses with additional features that need to be added are responsible for parsing those quads.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
Data to convert.
- - subject: Term
The identifier of the notification channel description in the dataset.
-
Returns Promise<NotificationChannel>
The generated NotificationChannel.
-- data: Store<Quad, Quad, Quad, Quad>
to
- to
Json Ld(channel): Promise<Record<string, unknown>> Converts the given channel to a JSON-LD description. -All fields found in the channel, except
-lastEmit, will be part of the result subject, -so subclasses should remove any fields that should not be exposed.Parameters
- channel: NotificationChannel
Returns Promise<Record<string, unknown>>
Protectedvalidate
- validate
Subscription(data): Promise<Term> Validates whether the given data conforms to the stored SHACL shape. -Will throw an UnprocessableEntityHttpError if validation fails. -Along with the SHACL check, this also makes sure there is only one matching entry in the dataset.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
The data to validate.
-
Returns Promise<Term>
The focus node that corresponds to the subject of the found notification channel description.
-- data: Store<Quad, Quad, Quad, Quad>
Class BaseClientCredentialsIdRoute
Implementation of an ClientCredentialsIdRoute -that adds the identifier relative to a base AccountIdRoute.
-Hierarchy (view full)
- IdInteractionRoute<AccountIdKey, CredentialsIdKey>
- BaseClientCredentialsIdRoute
Index
Constructors
Methods
Constructors
constructor
- new
Base Client Credentials Id Route(base): BaseClientCredentialsIdRoute Parameters
- base: AccountIdRoute
Returns BaseClientCredentialsIdRoute
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<"accountId" | "clientCredentialsId", string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<"accountId" | "clientCredentialsId", string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<"accountId" | "clientCredentialsId", string>
- path: string
Class BaseClientCredentialsStore
A ClientCredentialsStore that uses a AccountLoginStorage for storing the tokens. -Needs to be initialized before it can be used.
-Hierarchy (view full)
- Initializer
- BaseClientCredentialsStore
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Client Credentials Store(storage): BaseClientCredentialsStore Parameters
- storage: AccountLoginStorage<Record<string, never>>
Returns BaseClientCredentialsStore
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
create
- create(label, webId, accountId): Promise<ClientCredentials>
Creates new token.
-Parameters
- label: string
Identifier to use for the new token.
- - webId: string
WebID to identify as when using this token.
- - accountId: string
Returns Promise<ClientCredentials>
- label: string
delete
find
- find
By Account(accountId): Promise<ClientCredentials[]> Find all tokens created by the given account.
-Parameters
- accountId: string
ID of the account.
-
Returns Promise<ClientCredentials[]>
- accountId: string
find
- find
By Label(label): Promise<undefined | ClientCredentials> Find the ClientCredentials with the given label.
-Parameters
- label: string
Label of the token.
-
Returns Promise<undefined | ClientCredentials>
- label: string
get
- get(id): Promise<undefined | ClientCredentials>
Find the ClientCredentials with the given ID.
-Parameters
- id: string
ID of the token.
-
Returns Promise<undefined | ClientCredentials>
- id: string
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class BaseComponentsJsFactory
Can be used to instantiate objects using Components.js. -Default main module path is the root folder of the project. -For every generate call a new manager will be made, -but moduleState will be stored in between calls.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Components Js Factory(relativeModulePath?, logLevel?): BaseComponentsJsFactory Parameters
- relativeModulePath: string = '../../../'
- logLevel: string = 'error'
Returns BaseComponentsJsFactory
Methods
generate
- generate<T>(configPath, componentIri, variables): Promise<T>
Calls Components.js to instantiate a new object.
-Type Parameters
Parameters
- configPath: string
Location of the config to instantiate.
- - componentIri: string
Iri of the object in the config that will be the result.
- - variables: Record<string, unknown>
Variables to send to Components.js
-
Returns Promise<T>
The resulting object, corresponding to the given component IRI.
-- configPath: string
Class BaseCookieStore
A CookieStore that uses an ExpiringStorage to keep track of the stored cookies. -Cookies have a specified time to live in seconds, default is 14 days, -after which they will be removed.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Cookie Store(storage, ttl?): BaseCookieStore Parameters
- storage: ExpiringStorage<string, string>
- ttl: number = ...
Returns BaseCookieStore
Class BaseEmailSender
Sends e-mails using nodemailer.
-Hierarchy (view full)
- EmailSender
- BaseEmailSender
Index
Constructors
Methods
Constructors
constructor
- new
Base Email Sender(args): BaseEmailSender Parameters
- args: EmailSenderArgs
Returns BaseEmailSender
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: EmailArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: EmailArgs
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: EmailArgs
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: EmailArgs
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: EmailArgs
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: EmailArgs
Class BaseFileIdentifierMapper
Base class for FileIdentifierMapper implementations.
-Hierarchy (view full)
- BaseFileIdentifierMapper
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Base File Identifier Mapper(base, rootFilepath): BaseFileIdentifierMapper Parameters
- base: string
- rootFilepath: string
Returns BaseFileIdentifierMapper
Properties
Protected Readonlybase
Protected Readonlylogger
Protected Readonlyroot
Protected Readonlyunknown
Methods
Protectedget
Protectedget
Protectedget
Protectedget
- get
Content Type From Url(identifier, contentType?): Promise<string> Determines the content type from the document identifier.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<string>
The content type of the document.
-- identifier: ResourceIdentifier
Protectedget
Protectedget
- get
Relative Path(identifier): string Strips the baseRequestURI from the identifier.
-Parameters
- identifier: ResourceIdentifier
Incoming identifier.
-
Returns string
A string representing the relative path.
-- identifier: ResourceIdentifier
Protectedis
map
- map
File Path To Url(filePath, isContainer): Promise<ResourceLink> Maps the given file path to a URL and determines its content type.
-Parameters
- filePath: string
The input file path.
- - isContainer: boolean
If the path corresponds to a file.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- filePath: string
Protectedmap
- map
Url To Container Path(identifier, filePath): Promise<ResourceLink> Maps the given container identifier to a file path, -possibly making alterations to the direct translation.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedmap
- map
Url To Document Path(identifier, filePath, contentType?): Promise<ResourceLink> Maps the given document identifier to a file path, -possibly making alterations to the direct translation -(for instance, based on its content type)). -Determines the content type if none was provided.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
map
- map
Url To File Path(identifier, isMetadata, contentType?): Promise<ResourceLink> Maps the given resource identifier / URL to a file path. -Determines the content type if none was provided. -For containers the content-type input is ignored.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - isMetadata: boolean
If we need the data or metadata file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedvalidate
- validate
Relative Path(path, identifier): void Check whether the given relative path is valid.
-Parameters
- path: string
A relative path, as generated by getRelativePath.
- - identifier: ResourceIdentifier
A resource identifier.
-
Returns void
- path: string
Class BaseForgotPasswordStore
A ForgotPasswordStore using an ExpiringStorage to hold the necessary records.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Forgot Password Store(storage, ttl?): BaseForgotPasswordStore Parameters
- storage: ExpiringStorage<string, string>
- ttl: number = 15
Returns BaseForgotPasswordStore
Methods
delete
generate
- generate(email): Promise<string>
Creates a Forgot Password Confirmation Record. This will be to remember that -a user has made a request to reset a password. Throws an error if the email doesn't -exist.
-Parameters
- email: string
Returns Promise<string>
The record id. This should be included in the reset password link.
-
get
Class BaseIdentifierStrategyAbstract
Provides a default implementation for getParentContainer
-which checks if the identifier is supported and not a root container.
-If not, the last part before the first relevant slash will be removed to find the parent.
Provides a default implementation for contains
-which does standard slash-semantics based string comparison.
Hierarchy (view full)
- BaseIdentifierStrategy
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Identifier Strategy(): BaseIdentifierStrategy Returns BaseIdentifierStrategy
Methods
contains
- contains(container, identifier, transitive): boolean
Checks if the given container would contain the given identifier. -This does not check that either of these identifiers actually exist. -This is similar to calling getParentContainer on an identifier -and comparing the result.
-If
-transitiveisfalsethis only checks ifcontaineris the direct parent container ofidentifier.Parameters
- container: ResourceIdentifier
- identifier: ResourceIdentifier
- transitive: boolean
Returns boolean
get
- get
Parent Container(identifier): ResourceIdentifier Generates the identifier of the container this resource would be a member of. -This does not check if that identifier actually exists. -Will throw an error if the input identifier is a root container or is not supported.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
Abstractis
- is
Root Container(identifier): boolean Checks if the input corresponds to the identifier of a root container. -This does not check if this identifier actually exists.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
Abstractsupports
- supports
Identifier(identifier): boolean Verifies if this identifier is supported. -This does not check if this identifier actually exists, -but checks if the identifier is in scope for this class.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
Class BaseLoggerAbstract
Base class that implements all additional BaseLogger methods, -leaving only the implementation of SimpleLogger.
-Hierarchy (view full)
- BaseLogger
Implements
Constructors
constructor
- new
Base Logger(): BaseLogger Returns BaseLogger
Methods
debug
error
info
Abstractlog
- log(level, message, meta?): Logger
Log the given message at the given level. -If the internal level is higher than the given level, the message may be voided.
-Parameters
- level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly"The level to log at.
- - message: string
The message to log.
- Optionalmeta: LogMetadataOptional metadata to include in the log message.
-
Returns Logger
- level:
silly
verbose
warn
Class BaseLoginAccountStorage<T>
A LoginStorage that wraps around another IndexedStorage to add specific account requirements.
--
-
- New accounts will be removed after expiration time, in seconds, default is 1800, -if no login method was added to them in that time. -
- Non-login types can not be created until the associated account has at least 1 login method. -
- Login types can not be deleted if they are the last login of the associated account. -
All of this is tracked by adding a new field to the account object, -that keeps track of how many login objects are associated with the account.
-Type Parameters
- T extends IndexTypeCollection<T>
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Base Login Account Storage<T>(storage, expiration?): BaseLoginAccountStorage<T> Type Parameters
- T extends IndexTypeCollection<T>
Parameters
- storage: IndexedStorage<T>
- expiration: number = ...
Returns BaseLoginAccountStorage<T>
Properties
Protected Readonlyaccount
Protected Readonlylogin
Protected Readonlystorage
Methods
Protectedcheck
Protectedclean
create
- create<TType>(type, value): Promise<TypeObject<T[TType]>>
Creates an object of the given type. -The storage will generate an identifier for the newly created object.
-Type Parameters
Parameters
- type: TType
The type to create.
- - value: CreateTypeObject<T[TType]>
The value to set for the created object.
-
Returns Promise<TypeObject<T[TType]>>
A representation of the newly created object, including its new identifier.
-- type: TType
Protectedcreate
create
- create
Index<TType>(type, key): Promise<void> Creates an index on a key of the given type, to allow for better queries involving those keys. -Similar to IndexedStorage.defineType these calls need to happen first.
-Type Parameters
Parameters
Returns Promise<void>
define
- define
Type<TType>(type, description, isLogin): Promise<void> Defines a type in the storage, just like in an IndexedStorage, -but additionally it needs to be indicated if the type corresponds to a login method or not.
-Type Parameters
Parameters
Returns Promise<void>
delete
- delete<TType>(type, id): Promise<void>
Deletes the given object. -This will also delete all objects that reference that object if the corresponding key is not optional.
-Type Parameters
Parameters
- type: TType
The type of the object to delete.
- - id: string
The identifier of the object.
-
Returns Promise<void>
- type: TType
entries
- entries<TType>(type): AsyncIterableIterator<TypeObject<T[TType]>>
Returns an iterator over all objects of the given type.
-Type Parameters
Parameters
- type: TType
The type to iterate over.
-
Returns AsyncIterableIterator<TypeObject<T[TType]>>
- type: TType
find
- find<TType>(type, query): Promise<TypeObject<T[TType]>[]>
Finds all objects matching a specific IndexedQuery.
-Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<TypeObject<T[TType]>[]>
A list of objects matching the query.
-- type: TType
find
- find
Ids<TType>(type, query): Promise<string[]> Similar to IndexedStorage.find, but only returns the identifiers of the found objects.
-Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<string[]>
A list of identifiers of the matching objects.
-- type: TType
get
- get<TType>(type, id): Promise<undefined | TypeObject<T[TType]>>
Returns the object of the given type with the given identifier.
-Type Parameters
Parameters
- type: TType
The type of object to get.
- - id: string
The identifier of that object.
-
Returns Promise<undefined | TypeObject<T[TType]>>
A representation of the object, or
-undefinedif there is no object of that type with that identifier.- type: TType
has
set
- set<TType>(type, value): Promise<void>
Sets the value of a specific object. -The identifier in the object is used to identify the object.
-Type Parameters
Parameters
- type: TType
The type of the object to set.
- - value: TypeObject<T[TType]>
The new value for the object.
-
Returns Promise<void>
- type: TType
set
Class BasePasswordIdRoute
Implementation of an PasswordIdRoute that adds the identifier relative to a base AccountIdRoute.
-Hierarchy (view full)
- IdInteractionRoute<AccountIdKey, PasswordIdKey>
- BasePasswordIdRoute
Index
Constructors
Methods
Constructors
constructor
- new
Base Password Id Route(base): BasePasswordIdRoute Parameters
- base: AccountIdRoute
Returns BasePasswordIdRoute
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<"accountId" | "passwordId", string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<"accountId" | "passwordId", string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<"accountId" | "passwordId", string>
- path: string
Class BasePasswordStore
A PasswordStore that uses a KeyValueStorage to store the entries.
-Passwords are hashed and salted.
-Default saltRounds is 10.
Hierarchy (view full)
- Initializer
- BasePasswordStore
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Password Store(storage, saltRounds?): BasePasswordStore Parameters
- storage: AccountLoginStorage<Record<string, never>>
- saltRounds: number = 10
Returns BasePasswordStore
Methods
authenticate
- authenticate(email, password): Promise<{
accountId: string;
id: string;
}> Authenticate if the email and password are correct and return the account and login ID if they are. -Throw an error if they are not.
-Parameters
- email: string
The user's email.
- - password: string
This user's password.
-
Returns Promise<{
accountId: string;
id: string;
}>- email: string
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
confirm
- confirm
Verification(id): Promise<void> Confirms that the login has been verified. -This can be used with, for example, email verification. -The login can only be used after it is verified. -In case verification is not required, this should be called immediately after the
-createcall.Parameters
- id: string
ID of the login.
-
Returns Promise<void>
- id: string
create
delete
find
find
get
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
update
Class BasePodCreator
Handles the creation of pods. -Will call the stored PodStore with the provided settings.
-Hierarchy (view full)
- PodCreator
- BasePodCreator
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Base Pod Creator(args): BasePodCreator Parameters
- args: BasePodCreatorArgs
Returns BasePodCreator
Properties
Protected Readonlybase
Protected Readonlyidentifier
Protected Readonlylogger
Protected Readonlypod
Protected Readonlyrelative
Protected Readonlyweb
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PodCreatorInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PodCreatorInput
Protectedcreate
- create
Pod(accountId, settings, overwrite, webIdLink?): Promise<string> Creates a pod with the given settings. -In case pod creation fails, the given WebID link will be removed, if there is one, before throwing an error.
-Parameters
- accountId: string
- settings: PodSettings
- overwrite: boolean
OptionalwebIdLink: string
Returns Promise<string>
Protectedgenerate
- generate
Base Identifier(name?): ResourceIdentifier Parameters
Optionalname: string
Returns ResourceIdentifier
handle
- handle(input): Promise<PodCreatorOutput>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PodCreatorInput
Input that needs to be handled.
-
Returns Promise<PodCreatorOutput>
A promise resolving when handling is finished.
-- input: PodCreatorInput
handle
- handle
Safe(input): Promise<PodCreatorOutput> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PodCreatorInput
Input data that will be handled if it can be handled.
-
Returns Promise<PodCreatorOutput>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PodCreatorInput
Protectedhandle
- handle
Web Id(linkWebId, webId, accountId, settings): Promise<undefined | string> Links the WebID to the account if
-linkWebIdis true. -Also updates theoidcIssuervalue in the settings object in that case.Parameters
- linkWebId: boolean
- webId: string
- accountId: string
- settings: PodSettings
Returns Promise<undefined | string>
Class BasePodIdRoute
Implementation of an PodIdRoute that adds the identifier relative to a base AccountIdRoute.
-Hierarchy (view full)
- IdInteractionRoute<AccountIdKey, PodIdKey>
- BasePodIdRoute
Index
Constructors
Methods
Constructors
constructor
- new
Base Pod Id Route(base): BasePodIdRoute Parameters
- base: AccountIdRoute
Returns BasePodIdRoute
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<"accountId" | "podId", string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<"accountId" | "podId", string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<"accountId" | "podId", string>
- path: string
Class BasePodStore
A PodStore implementation using a PodManager to create pods -and a AccountLoginStorage to store the data. -Needs to be initialized before it can be used.
-Adds the initial WebID as the owner of the pod.
-By default, this owner is not exposed through a link header.
-This can be changed by setting the constructor visible parameter to true.
Hierarchy (view full)
- Initializer
- BasePodStore
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Pod Store(storage, manager, visible?): BasePodStore Parameters
- storage: AccountLoginStorage<Record<string, never>>
- manager: PodManager
- visible: boolean = false
Returns BasePodStore
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
create
- create(accountId, settings, overwrite): Promise<string>
Creates a new pod and updates the account accordingly.
-Parameters
- accountId: string
Identifier of the account that is creating the account.
- - settings: PodSettings
Settings to create a pod with.
- - overwrite: boolean
If the pod is allowed to overwrite existing data.
-
Returns Promise<string>
The ID of the new pod resource.
-- accountId: string
find
find
get
get
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
remove
- remove
Owner(id, webId): Promise<void> Remove an owner from a pod. -This should not remove the last owner as a pod always needs to have at least one owner. -https://solidproject.org/TR/2022/protocol-20221231#server-storage-track-owner
-Parameters
- id: string
ID of the pod.
- - webId: string
WebID of the owner.
-
Returns Promise<void>
- id: string
update
- update
Owner(id, webId, visible): Promise<void> Add or update an owner of a pod. -In case there already is an owner with this WebID, it will be updated, -otherwise a new owner will be added.
-Parameters
- id: string
ID of the pod.
- - webId: string
WebID of the owner.
- - visible: boolean
Whether the owner wants to be exposed or not.
-
Returns Promise<void>
- id: string
Class BaseReadWriteLockerAbstract
A ReadWriteLocker that allows for multiple simultaneous read operations. -Write operations will be blocked as long as read operations are not finished. -New read operations are allowed while this is going on, which will cause write operations to wait longer.
-Based on https://en.wikipedia.org/wiki/Readers–writer_lock#Using_two_mutexes . -As soon as 1 read lock request is made, the main lock is locked. -Internally a counter keeps track of the amount of active read locks. -Only when this number reaches 0 will the main lock be released again. -The internal count lock is only locked to increase/decrease this counter and is released afterwards. -This allows for multiple read operations, although only 1 at the time can update the counter, -which means there can still be a small waiting period if there are multiple simultaneous read operations.
-Classes extending this need to implement getCountLockIdentifier and modifyCount.
Hierarchy (view full)
- EqualReadWriteLocker
- BaseReadWriteLocker
Index
Constructors
Properties
Methods
Constructors
Protectedconstructor
- new
Base Read Write Locker(resourceLocker, countLocker): BaseReadWriteLocker Parameters
- resourceLocker: ResourceLocker
Used for creating read and write locks.
- - countLocker: ResourceLocker
Used for creating locks when updating the counter.
-
Returns BaseReadWriteLocker
- resourceLocker: ResourceLocker
Methods
Protected Abstractget
- get
Count Lock Identifier(identifier): ResourceIdentifier Generate the identifier that will be used to acquire the count lock for the given identifier. -There will be cases where this lock needs to be acquired -while an active lock on the main resource is still being maintained. -This means that if the input
-resourceLockerandcountLockeruse the same locking system -this generated identifier needs to be different.Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
Protected Abstractmodify
- modify
Count(identifier, mod): PromiseOrValue<number> Update the counter that keeps track of having open read locks there currently are.
-Parameters
- identifier: ResourceIdentifier
Identifier on which to update the number of read locks.
- - mod: number
-+1or-1.
Returns PromiseOrValue<number>
- identifier: ResourceIdentifier
Protectedwith
- with
Lock<T>(identifier, whileLocked): Promise<T> Acquires a new lock for the requested identifier. -Will resolve when the input function resolves.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
Function to resolve while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Class BaseResourceStore
Base implementation of ResourceStore for implementers of custom stores.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Resource Store(): BaseResourceStore Returns BaseResourceStore
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class BaseResourcesGenerator
Generates resources by making use of a template engine. -The template folder structure will be kept. -Folders will be interpreted as containers and files as documents. -A FileIdentifierMapper will be used to generate identifiers that correspond to the relative structure.
-Metadata resources will be yielded separately from their subject resource.
-A relative templateFolder is resolved relative to cwd,
-unless it's preceded by @css:, e.g. @css:foo/bar.
Implements
Index
Constructors
constructor
- new
Base Resources Generator(args): BaseResourcesGenerator A mapper is needed to convert the template file paths to identifiers relative to the given base identifier.
-Parameters
- args: SubfolderResourcesGeneratorArgs
TemplatedResourcesGeneratorArgs
-
Returns BaseResourcesGenerator
- args: SubfolderResourcesGeneratorArgs
Methods
generate
- generate(templateFolder, location, options): AsyncIterable<Resource>
Generates resources with the given options, based on the given template folder. -The output Iterable should be sorted so that containers always appear before their contents.
-Parameters
- templateFolder: string
Folder where the templates are located.
- - location: ResourceIdentifier
Base identifier.
- - options: Dict<unknown>
Options that can be used when generating resources.
-
Returns AsyncIterable<Resource>
A map where the keys are the identifiers and the values the corresponding representations to store.
-- templateFolder: string
Class BaseRouterHandler<T>Abstract
Checks if a given method and path are satisfied and allows its handler to be executed if so.
-Implementations of this class should call canHandleInput in their canHandle call with the correct parameters.
canHandleInput expects a ResourceIdentifier to indicate it expects the target to have been validated already.
Type Parameters
- T extends AsyncHandler<unknown, unknown>
Hierarchy (view full)
- AsyncHandler<AsyncHandlerInput<T>, AsyncHandlerOutput<T>>
- BaseRouterHandler
Index
Constructors
Properties
Methods
Constructors
Protectedconstructor
- new
Base Router Handler<T>(args): BaseRouterHandler<T> Type Parameters
- T extends AsyncHandler<unknown, unknown>
Parameters
- args: BaseRouterHandlerArgs<T>
Returns BaseRouterHandler<T>
Properties
Protected Readonlyall
Protected Readonlyallowed
Protected Readonlyallowed
Protected Readonlybase
Protected Readonlyhandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AsyncHandlerInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Protectedcan
- can
Handle Input(input, method, target): Promise<void> Parameters
- input: AsyncHandlerInput<T>
- method: string
- target: ResourceIdentifier
Returns Promise<void>
handle
- handle(input): Promise<AsyncHandlerOutput<T>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AsyncHandlerInput<T>
Input that needs to be handled.
-
Returns Promise<AsyncHandlerOutput<T>>
A promise resolving when handling is finished.
-- input: AsyncHandlerInput<T>
handle
- handle
Safe(input): Promise<Awaited<ReturnType<T["handle"]>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AsyncHandlerInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<Awaited<ReturnType<T["handle"]>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Class BaseServerFactory
Creates an HTTP(S) server native Node.js http/https modules.
Will apply a ServerConfigurator to the server, -which should be used to attach listeners.
-Implements
Index
Constructors
constructor
- new
Base Server Factory(configurator, options?): BaseServerFactory Parameters
- configurator: ServerConfigurator
Optionaloptions: BaseServerFactoryOptions
Returns BaseServerFactory
Class BaseStateHandler
Handles the state feature by calling a NotificationHandler
-in case the NotificationChannel has a state value.
Deletes the state parameter from the channel afterwards.
Hierarchy (view full)
- StateHandler
- BaseStateHandler
Index
Constructors
constructor
- new
Base State Handler(handler, storage): BaseStateHandler Parameters
- handler: NotificationHandler
- storage: NotificationChannelStorage
Returns BaseStateHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
channel: NotificationChannel;
}Input that could potentially be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
channel: NotificationChannel;
}Input that needs to be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
channel: NotificationChannel;
}Input data that will be handled if it can be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class BaseTypedRepresentationConverterAbstract
A base TypedRepresentationConverter implementation for converters -that can convert from all its input types to all its output types.
-This base class handles the canHandle call by comparing the input content type to the stored input types
-and the output preferences to the stored output types.
Output weights are determined by multiplying all stored output weights with the weight of the input type.
-Hierarchy (view full)
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Base Typed Representation Converter(inputTypes, outputTypes): BaseTypedRepresentationConverter Parameters
- inputTypes: ValuePreferencesArg
- outputTypes: ValuePreferencesArg
Returns BaseTypedRepresentationConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class BaseUrlExtractor
A ShorthandExtractor that that generates the base URL based on the input baseUrl value,
-or by using the port if the first isn't provided.
Hierarchy (view full)
- ShorthandExtractor
- BaseUrlExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Base Url Extractor(defaultPort?): BaseUrlExtractor Parameters
- defaultPort: number = 3000
Returns BaseUrlExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
handle
- handle(args): Promise<unknown>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- args: Shorthand
Returns Promise<unknown>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<unknown> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<unknown>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class BaseUrlHandler
Adds the pod identifier as base url variable to the agent. -This allows for config templates that require a value for TEMPLATE_BASE_URL_URN, -which should equal the pod identifier.
-Hierarchy (view full)
- VariableHandler
- BaseUrlHandler
Index
Constructors
Methods
Constructors
constructor
- new
Base Url Handler(): BaseUrlHandler Returns BaseUrlHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that needs to be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class BaseUrlRouterRule
Routes requests based on their base url. -Checks if any of the stored base URLs match the request identifier. -If there are no matches the base store will be returned if one was configured.
-Part of the dynamic pod creation. -Uses the identifiers that were added to the routing storage.
-Hierarchy (view full)
- RouterRule
- BaseUrlRouterRule
Index
Constructors
Methods
Constructors
constructor
- new
Base Url Router Rule(stores, baseStore?): BaseUrlRouterRule Parameters
- stores: KeyValueStorage<string, ResourceStore>
OptionalbaseStore: ResourceStore
Returns BaseUrlRouterRule
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<ResourceStore>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
}Input that needs to be handled.
-identifier: ResourceIdentifier
Returns Promise<ResourceStore>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceStore> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class BaseUrlVerifier
Stores the baseUrl value that was used to start the server
-and warns the user in case it differs from the previous one.
Hierarchy (view full)
- Initializer
- BaseUrlVerifier
Index
Constructors
Methods
Constructors
constructor
- new
Base Url Verifier(baseUrl, storageKey, storage): BaseUrlVerifier Parameters
- baseUrl: string
- storageKey: string
- storage: KeyValueStorage<string, string>
Returns BaseUrlVerifier
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class BaseWebIdLinkRoute
Implementation of an WebIdLinkRoute that adds the identifier relative to a base AccountIdRoute.
-Hierarchy (view full)
- IdInteractionRoute<AccountIdKey, WebIdLinkKey>
- BaseWebIdLinkRoute
Index
Constructors
Methods
Constructors
constructor
- new
Base Web Id Link Route(base): BaseWebIdLinkRoute Parameters
- base: AccountIdRoute
Returns BaseWebIdLinkRoute
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<"accountId" | "webIdLink", string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<"accountId" | "webIdLink", string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<"accountId" | "webIdLink", string>
- path: string
Class BaseWebIdStore
A WebIdStore using a AccountLoginStorage to store the links. -Needs to be initialized before it can be used.
-Hierarchy (view full)
- Initializer
- BaseWebIdStore
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Base Web Id Store(storage): BaseWebIdStore Parameters
- storage: AccountLoginStorage<Record<string, never>>
Returns BaseWebIdStore
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
create
delete
find
get
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
is
Class BasicConditions
Stores all the relevant Conditions values and matches them based on RFC7232.
-Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Basic Conditions(eTagHandler, options): BasicConditions Parameters
- eTagHandler: ETagHandler
- options: BasicConditionsOptions
Returns BasicConditions
Properties
Protected Readonlye
Optional ReadonlymatchesETag
Valid if matching any of the given ETags.
-Optional Readonlymodified
Valid if modified since the given date.
-Optional Readonlynot
Valid if not matching any of the given ETags.
-Optional Readonlyunmodified
Valid if not modified since the given date.
- Methods
matches
- matches
Metadata(metadata?, strict?): boolean Checks validity based on the given metadata.
-Parameters
Optionalmetadata: RepresentationMetadataMetadata of the representation. Undefined if the resource does not exist.
-Optionalstrict: booleanHow to compare the ETag related headers. -If true, the comparison will happen on representation level. -If false, the comparison happens on resource level, ignoring the content-type.
-
Returns boolean
Class BasicConditionsParser
Creates a Conditions object based on the following headers:
--
-
- If-Modified-Since -
- If-Unmodified-Since -
- If-Match -
- If-None-Match -
Implementation based on RFC7232
-Hierarchy (view full)
- ConditionsParser
- BasicConditionsParser
Index
Constructors
constructor
- new
Basic Conditions Parser(eTagHandler): BasicConditionsParser Parameters
- eTagHandler: ETagHandler
Returns BasicConditionsParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(request): Promise<undefined | Conditions>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- request: HttpRequest
Returns Promise<undefined | Conditions>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<undefined | Conditions> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<undefined | Conditions>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class BasicETagHandler
Standard implementation of ETagHandler. -ETags are constructed by combining the last modified date with the content type of the representation.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
BasicETag Handler(): BasicETagHandler Returns BasicETagHandler
Methods
getETag
- getETag(metadata): undefined | string
Generates an ETag for the given metadata. Returns undefined if no ETag could be generated.
-Parameters
- metadata: RepresentationMetadata
Metadata of the representation to generate an ETag for.
-
Returns undefined | string
- metadata: RepresentationMetadata
matchesETag
- matchesETag(metadata, eTag, strict): boolean
Validates whether the given metadata corresponds to the given ETag.
-Parameters
- metadata: RepresentationMetadata
Metadata of the resource.
- - eTag: string
ETag to compare to.
- - strict: boolean
True if the comparison needs to be on representation level. -False if it is on resource level and the content-type doesn't matter.
-
Returns boolean
- metadata: RepresentationMetadata
same
Class BasicRepresentation
Class with various constructors to facilitate creating a representation.
-A representation consists of 1) data, 2) metadata, and 3) a binary flag -to indicate whether the data is a binary stream or an object stream.
--
-
- The data can be given as a stream, array, or string. -
- The metadata can be specified as one or two parameters -that will be passed to the RepresentationMetadata constructor. -
- The binary field is optional, and if not specified, -is determined from the content type inside the metadata. -
Implements
Index
Constructors
constructor
- new
Basic Representation(): BasicRepresentation An empty Representation
-Returns BasicRepresentation
- new
Basic Representation(data, metadata, binary?): BasicRepresentation Parameters
- data:
| string
| Readable
| unknown[]
| Guarded<Readable>The representation data
- - metadata: MetadataRecord | RepresentationMetadata
The representation metadata
- Optionalbinary: booleanWhether the representation is a binary or object stream
-
Returns BasicRepresentation
- data:
- new
Basic Representation(data, metadata, contentType?, binary?): BasicRepresentation Parameters
- data:
| string
| Readable
| unknown[]
| Guarded<Readable>The representation data
- - metadata: MetadataRecord | RepresentationMetadata
The representation metadata
- OptionalcontentType: stringThe representation's content type
-Optionalbinary: booleanWhether the representation is a binary or object stream
-
Returns BasicRepresentation
- data:
- new
Basic Representation(data, contentType, binary?): BasicRepresentation Parameters
- data:
| string
| Readable
| unknown[]
| Guarded<Readable>The representation data
- - contentType: string
The representation's content type
- Optionalbinary: booleanWhether the representation is a binary or object stream
-
Returns BasicRepresentation
- data:
- new
Basic Representation(data, identifier, metadata?, binary?): BasicRepresentation Parameters
- data:
| string
| Readable
| unknown[]
| Guarded<Readable>The representation data
- - identifier: MetadataIdentifier
The representation's identifier
- Optionalmetadata: MetadataRecordThe representation metadata
-Optionalbinary: booleanWhether the representation is a binary or object stream
-
Returns BasicRepresentation
- data:
- new
Basic Representation(data, identifier, contentType?, binary?): BasicRepresentation Parameters
- data:
| string
| Readable
| unknown[]
| Guarded<Readable>The representation data
- - identifier: MetadataIdentifier
The representation's identifier
- OptionalcontentType: stringThe representation's content type
-Optionalbinary: booleanWhether the representation is a binary or object stream
-
Returns BasicRepresentation
- data:
Class BasicRequestParser
Creates an Operation from an incoming HttpRequest by aggregating the results -of a TargetExtractor, MetadataParser, -ConditionsParser and BodyParser.
-Hierarchy (view full)
- RequestParser
- BasicRequestParser
Index
Constructors
Methods
Constructors
constructor
- new
Basic Request Parser(args): BasicRequestParser Parameters
- args: BasicRequestParserArgs
Returns BasicRequestParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(request): Promise<Operation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- request: HttpRequest
Returns Promise<Operation>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Operation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Operation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class BasicResponseWriter
Writes to an HttpResponse based on the incoming ResponseDescription.
-Hierarchy (view full)
- ResponseWriter
- BasicResponseWriter
Index
Constructors
constructor
- new
Basic Response Writer(metadataWriter): BasicResponseWriter Parameters
- metadataWriter: MetadataWriter
Returns BasicResponseWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input that could potentially be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input that needs to be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input data that will be handled if it can be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class BearerWebIdExtractor
Responsible for extracting credentials from an incoming request.
-Hierarchy (view full)
- CredentialsExtractor
- BearerWebIdExtractor
Index
Constructors
constructor
- new
Bearer Web Id Extractor(): BearerWebIdExtractor Returns BearerWebIdExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(request): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- request: HttpRequest
Returns Promise<Credentials>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class BinarySliceResourceStore<T>
Resource store that slices the data stream if there are range preferences.
-Only works for bytes range preferences on binary data streams.
-Does not support multipart range requests.
If the slice happens, unit/start/end values will be written to the metadata to indicate such. -The values are dependent on the preferences we got as an input, -as we don't know the actual size of the data stream.
-Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- PassthroughStore<T>
- BinarySliceResourceStore
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Binary Slice Resource Store<T>(source): BinarySliceResourceStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
Returns BinarySliceResourceStore<T>
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class BodyParserAbstract
Parses the body of an incoming HttpRequest and converts it to a Representation.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Body Parser(): BodyParser Returns BodyParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: BodyParserArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: BodyParserArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: BodyParserArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: BodyParserArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
Class BooleanHandler<TIn>
A composite handler that returns true if any of its handlers can handle the input and return true. -Handler errors are interpreted as false results.
-Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, boolean>
- BooleanHandler
Index
Constructors
constructor
- new
Boolean Handler<TIn>(handlers): BooleanHandler<TIn> Creates a new BooleanHandler that stores the given handlers.
-Type Parameters
Parameters
- handlers: AsyncHandler<TIn, boolean>[]
Handlers over which it will run.
-
Returns BooleanHandler<TIn>
- handlers: AsyncHandler<TIn, boolean>[]
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<boolean>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<boolean>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<boolean> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<boolean>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class CachedHandler<TIn, TOut>
Caches output data from the source handler based on the input object.
-The fields parameter can be used to instead use one or more specific entries from the input object as cache key,
-so has as actual required typing (keyof TIn)[].
A WeakMap is used internally so strict object equality determines cache hits, -and data will be removed once the key stops existing. -This also means that the cache key needs to be an object. -Errors will be thrown in case a primitive is used.
-Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut>
- CachedHandler
Index
Constructors
Methods
Constructors
constructor
- new
Cached Handler<TIn, TOut>(source, fields?): CachedHandler<TIn, TOut> Type Parameters
Parameters
- source: AsyncHandler<TIn, TOut>
Optionalfields: string[]
Returns CachedHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Protectedfind
- find
Destination(input, keys, cache, ensure?): undefined | WeakMap<object, TOut> Returns the
-WeakMapthat contains actual objects that were cached, -so the lastWeakMapin the chain of maps.Returns
-undefinedif no such map exists because earlier keys were not cached.Will always return a map if
-ensureis set to true, -in such a case the intermediate maps will be created and added to the previous map.Returns undefined | WeakMap<object, TOut>
Protectedget
- get
Keys(input): [object, ...object[]] Extracts the values that will be used as keys from the input object. -In case the
-fieldsvalue was undefined, this will return an array containing the input object itself.Parameters
- input: TIn
Returns [object, ...object[]]
handle
- handle(input): Promise<TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class CachedJwkGenerator
Generates a key pair once and then caches it using both an internal variable and a KeyValueStorage. -The storage makes sure the keys remain the same between server restarts, -while the internal variable makes it so the storage doesn't have to be accessed every time a key is needed.
-Only the private key is stored in the internal storage, using the storageKey parameter.
-The public key is determined based on the private key and then also stored in memory.
Implements
Index
Constructors
constructor
- new
Cached Jwk Generator(alg, storageKey, storage): CachedJwkGenerator Parameters
- alg: AsymmetricSigningAlgorithm
The algorithm used for the keys.
- - storageKey: string
- storage: KeyValueStorage<string, JWKS>
Returns CachedJwkGenerator
- alg: AsymmetricSigningAlgorithm
Class CachedResourceSet
Caches resource existence in a WeakMap tied to the ResourceIdentifier object.
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Cached Resource Set(source): CachedResourceSet Parameters
- source: ResourceSet
Returns CachedResourceSet
Methods
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
Class CancelOidcHandler
Cancel an active OIDC interaction.
-Hierarchy (view full)
- JsonInteractionHandler<never>
- CancelOidcHandler
Index
Constructors
Methods
Constructors
constructor
- new
Cancel Oidc Handler(): CancelOidcHandler Returns CancelOidcHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<never>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<never>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ChainedConverter
A meta converter that takes an array of other converters as input. -It chains these converters by finding a path of converters -that can go from the given content-type to the given type preferences. -In case there are multiple paths, the one with the highest weight gets found. -Will error in case no path can be found.
-This is not a TypedRepresentationConverter since the supported output types -might depend on what is the input content-type.
-This converter should be the last in a WaterfallHandler if there are multiple, -since it will try to convert any representation with a content-type.
-Some suggestions on how this class can be even more optimized should this ever be needed in the future. -Most of these decrease computation time at the cost of more memory.
--
-
- The algorithm could start on both ends of a possible path and work towards the middle. -
- When creating a path, store the list of unused converters instead of checking every step. -
- Caching: https://github.com/CommunitySolidServer/CommunitySolidServer/issues/832 -
- Making sure each intermediate type is only used once. -
- The TypedRepresentationConverter interface could potentially be updated -so paths only differing in intermediate types can be combined. -
Hierarchy (view full)
- RepresentationConverter
- ChainedConverter
Index
Constructors
constructor
- new
Chained Converter(converters): ChainedConverter Parameters
- converters: TypedRepresentationConverter[]
Returns ChainedConverter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ChainedTemplateEngine<T>
Calls the given array of TemplateEngines in the order they appear, -feeding the output of one into the input of the next.
-The first engine will be called with the provided contents and template parameters. -All subsequent engines will be called with no template parameter. -Contents will still be passed along and another entry will be added for the body of the previous output.
-Type Parameters
Hierarchy (view full)
- TemplateEngine<T>
- ChainedTemplateEngine
Index
Constructors
Methods
Constructors
constructor
- new
Chained Template Engine<T>(engines, renderedName?): ChainedTemplateEngine<T> Type Parameters
Parameters
- engines: TemplateEngine<Dict<unknown>>[]
Engines will be executed in the same order as the array.
- - renderedName: string = 'body'
The name of the key used to pass the body of one engine to the next.
-
Returns ChainedTemplateEngine<T>
- engines: TemplateEngine<Dict<unknown>>[]
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
handle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class CliExtractorAbstract
Converts the input CLI arguments into an easily parseable key/value object.
-Due to how the application is built, there are certain CLI parameters -that need to be parsed before this class can be instantiated. -These can be ignored by this class as they will have been handled before it is called, -but that does mean that this class should not error if they are present, -e.g., by being strict throwing an error on these unexpected parameters.
-In case strict mode is preferred, the following should be added to the list of known parameters:
--
-
- -c / --config -
- -m / --mainModulePath -
- -l / --loggingLevel -
Hierarchy (view full)
- AsyncHandler<CliArgv, Shorthand>
- CliExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Cli Extractor(): CliExtractor Returns CliExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: CliArgv
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: CliArgv
Abstracthandle
- handle(input): Promise<Shorthand>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: CliArgv
Input that needs to be handled.
-
Returns Promise<Shorthand>
A promise resolving when handling is finished.
-- input: CliArgv
handle
- handle
Safe(input): Promise<Shorthand> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: CliArgv
Input data that will be handled if it can be handled.
-
Returns Promise<Shorthand>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: CliArgv
Class CliResolver
A class that combines a CliExtractor and a ShorthandResolver. -Mainly exists so both such classes can be generated in a single Components.js instance.
- Index
Constructors
Properties
Constructors
constructor
- new
Cli Resolver(cliExtractor, shorthandResolver): CliResolver Parameters
- cliExtractor: CliExtractor
- shorthandResolver: ShorthandResolver
Returns CliResolver
Class ClientCredentialsAdapter
A PassthroughAdapter that overrides the find function
-by checking if there are stored client credentials for the given ID
-if no payload is found in the source.
Hierarchy (view full)
- PassthroughAdapter
- ClientCredentialsAdapter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Client Credentials Adapter(name, source, webIdStore, clientCredentialsStore): ClientCredentialsAdapter Parameters
- name: string
- source: Adapter
- webIdStore: WebIdStore
- clientCredentialsStore: ClientCredentialsStore
Returns ClientCredentialsAdapter
Properties
Protected Readonlylogger
Protected Readonlyname
Protected Readonlysource
Class ClientCredentialsAdapterFactory
A factory that generates an Adapter to be used by the IDP to persist information.
The oidc-provider library will call the relevant functions when it needs to find/create/delete metadata.
-For a full explanation of how these functions work and what is expected,
-have a look at https://github.com/panva/node-oidc-provider/blob/main/example/my_adapter.js
Hierarchy (view full)
- PassthroughAdapterFactory
- ClientCredentialsAdapterFactory
Index
Constructors
constructor
- new
Client Credentials Adapter Factory(source, webIdStore, clientCredentialsStore): ClientCredentialsAdapterFactory Parameters
- source: AdapterFactory
- webIdStore: WebIdStore
- clientCredentialsStore: ClientCredentialsStore
Returns ClientCredentialsAdapterFactory
Class ClientCredentialsDetailsHandler
Provides a view on a client credentials token, indicating the token identifier and its associated WebID.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- ClientCredentialsDetailsHandler
Index
Constructors
constructor
- new
Client Credentials Details Handler(clientCredentialsStore, clientCredentialsRoute): ClientCredentialsDetailsHandler Parameters
- clientCredentialsStore: ClientCredentialsStore
- clientCredentialsRoute: ClientCredentialsIdRoute
Returns ClientCredentialsDetailsHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ClientIdAdapter
This Adapter redirects the find call to its source adapter.
-In case no client data was found in the source for the given Client ID,
-this class will do an HTTP GET request to that Client ID.
-If the result is a valid Client ID document, that will be returned instead.
See https://solidproject.org/TR/2022/oidc-20220328#clientids-document.
-Hierarchy (view full)
- PassthroughAdapter
- ClientIdAdapter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Client Id Adapter(name, source, converter): ClientIdAdapter Parameters
- name: string
- source: Adapter
- converter: RepresentationConverter
Returns ClientIdAdapter
Properties
Protected Readonlylogger
Protected Readonlyname
Protected Readonlysource
Class ClientIdAdapterFactory
A factory that generates an Adapter to be used by the IDP to persist information.
The oidc-provider library will call the relevant functions when it needs to find/create/delete metadata.
-For a full explanation of how these functions work and what is expected,
-have a look at https://github.com/panva/node-oidc-provider/blob/main/example/my_adapter.js
Hierarchy (view full)
- PassthroughAdapterFactory
- ClientIdAdapterFactory
Index
Constructors
constructor
- new
Client Id Adapter Factory(source, converter): ClientIdAdapterFactory Parameters
- source: AdapterFactory
- converter: RepresentationConverter
Returns ClientIdAdapterFactory
Class ClientInfoHandler
Returns a JSON representation with metadata of the client that is requesting the OIDC interaction.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- ClientInfoHandler
Index
Constructors
Methods
Constructors
constructor
- new
Client Info Handler(providerFactory): ClientInfoHandler Parameters
- providerFactory: ProviderFactory
Returns ClientInfoHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ClusterManager
This class is responsible for deciding how many affective workers are needed. -It also contains the logic for respawning workers when they are killed by the os.
-The workers values are interpreted as follows:
-| value | -actual workers | -
|---|---|
-m |
-num_cores - m workers (autoscale) (m < num_cores) |
-
-1 |
-num_cores - 1 workers (autoscale) |
-
0 |
-num_cores workers (autoscale) |
-
1 |
-single threaded mode (default) |
-
n |
-n workers |
-
Index
Constructors
Methods
Constructors
constructor
- new
Cluster Manager(workers): ClusterManager Parameters
- workers: number
Returns ClusterManager
Class CombinedShorthandResolver
Generates variable values by running a set of ShorthandExtractors on the input.
-Hierarchy (view full)
- ShorthandResolver
- CombinedShorthandResolver
Index
Constructors
constructor
- new
Combined Shorthand Resolver(resolvers): CombinedShorthandResolver Parameters
- resolvers: Record<string, ShorthandExtractor>
Returns CombinedShorthandResolver
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
handle
- handle(input): Promise<Record<string, unknown>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Record<string, unknown>
Input that needs to be handled.
-
Returns Promise<Record<string, unknown>>
A promise resolving when handling is finished.
-- input: Record<string, unknown>
handle
- handle
Safe(input): Promise<VariableBindings> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<VariableBindings>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class ComposedAuxiliaryStrategy
An AuxiliaryStrategy that provides its functionality through the combination of -an AuxiliaryIdentifierStrategy, MetadataGenerator and Validator.
-Implements
Index
Constructors
constructor
- new
Composed Auxiliary Strategy(identifierStrategy, metadataGenerator?, validator?, ownAuthorization?, requiredInRoot?): ComposedAuxiliaryStrategy Parameters
- identifierStrategy: AuxiliaryIdentifierStrategy
OptionalmetadataGenerator: MetadataGeneratorOptionalvalidator: Validator- ownAuthorization: boolean = false
- requiredInRoot: boolean = false
Returns ComposedAuxiliaryStrategy
Methods
add
- add
Metadata(metadata): Promise<void> Adds metadata related to this auxiliary resource, -in case this is required for this type of auxiliary resource. -The metadata that is added depends on the given identifier being an auxiliary or subject resource: -the metadata will be used to link to the other one, and potentially add extra typing info.
-Used for: -Solid, §4.3.1: "For any defined auxiliary resource available for a given Solid resource, all representations of -that resource MUST include an HTTP Link header pointing to the location of each auxiliary resource." -https://solid.github.io/specification/protocol#auxiliary-resources-server
-The above is an example of how that metadata would only be added in case the input is the subject identifier.
-Parameters
- metadata: RepresentationMetadata
Metadata to update.
-
Returns Promise<void>
- metadata: RepresentationMetadata
get
- get
Auxiliary Identifier(identifier): ResourceIdentifier Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the corresponding auxiliary resource.
-- identifier: ResourceIdentifier
get
- get
Auxiliary Identifiers(identifier): ResourceIdentifier[] Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
get
- get
Subject Identifier(identifier): ResourceIdentifier Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
- is
Auxiliary Identifier(identifier): boolean Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
is
uses
validate
- validate(representation): Promise<void>
Validates if the representation contains valid data for an auxiliary resource. -Should throw an error in case the data is invalid.
-Parameters
- representation: Representation
Representation of the auxiliary resource.
-
Returns Promise<void>
- representation: Representation
Class ComposedNotificationHandler
Generates, serializes and emits a Notification using a NotificationGenerator, -NotificationSerializer and NotificationEmitter.
-Will not emit an event when it has the same state as the notification channel.
-Hierarchy (view full)
- NotificationHandler
- ComposedNotificationHandler
Index
Constructors
Methods
Constructors
constructor
- new
Composed Notification Handler(args): ComposedNotificationHandler Parameters
Returns ComposedNotificationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class ConditionalHandler<TIn, TOut>
This handler will pass all requests to the wrapped handler, -until a specific value has been set in the given storage. -After that all input will be rejected. -Once the value has been matched this behaviour will be cached, -so changing the value again afterwards will not enable this handler again.
-If handleStorage is set to true,
-this handler will set the value itself in the given storage after the source handler successfully resolved.
Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut>
- ConditionalHandler
Index
Constructors
Methods
Constructors
constructor
- new
Conditional Handler<TIn, TOut>(source, storage, storageKey, storageValue, handleStorage?): ConditionalHandler<TIn, TOut> Type Parameters
Parameters
- source: AsyncHandler<TIn, TOut>
- storage: KeyValueStorage<string, unknown>
- storageKey: string
- storageValue: unknown
- handleStorage: boolean = false
Returns ConditionalHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class ConditionsParserAbstract
Creates a Conditions object based on the input HttpRequest.
-Hierarchy (view full)
- AsyncHandler<HttpRequest, Conditions | undefined>
- ConditionsParser
Index
Constructors
Methods
Constructors
constructor
- new
Conditions Parser(): ConditionsParser Returns ConditionsParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Abstracthandle
- handle(input): Promise<undefined | Conditions>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpRequest
Input that needs to be handled.
-
Returns Promise<undefined | Conditions>
A promise resolving when handling is finished.
-- input: HttpRequest
handle
- handle
Safe(input): Promise<undefined | Conditions> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<undefined | Conditions>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class ConfigPodInitializer
Initializes all pods that have been stored and loads them in memory. -This reads the pod settings from a permanent storage and uses those -to create the corresponding ResourceStores in memory, -so this is required every time the server starts.
-Part of the dynamic pod creation. -Reads the contents from the configuration storage, uses those values to instantiate ResourceStores, -and then adds them to the routing storage.
-Hierarchy (view full)
- Initializer
- ConfigPodInitializer
Index
Constructors
constructor
- new
Config Pod Initializer(storeFactory, configStorage, routingStorage): ConfigPodInitializer Parameters
- storeFactory: ComponentsJsFactory
- configStorage: KeyValueStorage<string, unknown>
- routingStorage: KeyValueStorage<string, ResourceStore>
Returns ConfigPodInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class ConfigPodManager
Pod manager that creates a store for the pod with a PodGenerator -and fills it with resources from a ResourcesGenerator.
-Part of the dynamic pod creation.
--
-
- Calls a PodGenerator to instantiate a new resource store for the pod. -
- Generates the pod resources based on the templates as usual. -
- Adds the created pod to the routing storage, which is used for linking pod identifiers to their resource stores. -
Implements
Index
Constructors
constructor
- new
Config Pod Manager(podGenerator, resourcesGenerator, routingStorage, store): ConfigPodManager Parameters
- podGenerator: PodGenerator
Generator for the pod stores.
- - resourcesGenerator: ResourcesGenerator
Generator for the pod resources.
- - routingStorage: KeyValueStorage<string, ResourceStore>
Where to store the generated pods so they can be routed to.
- - store: ResourceStore
The default ResourceStore
-
Returns ConfigPodManager
- podGenerator: PodGenerator
Methods
create
- create
Pod(settings): Promise<void> Creates a pod for the given settings.
-Parameters
- settings: PodSettings
Settings describing the pod.
-
Returns Promise<void>
- settings: PodSettings
Class ConflictHttpError
An error thrown when a request conflict with current state of the server.
-Hierarchy
- BaseHttpError
- ConflictHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Conflict Http Error(message?, options?): ConflictHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns ConflictHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class ConsentHandler
Handles the OIDC consent prompts where the user confirms they want to log in for the given client.
-Hierarchy (view full)
- JsonInteractionHandler<never>
- ConsentHandler
Index
Constructors
Methods
Constructors
constructor
- new
Consent Handler(providerFactory): ConsentHandler Parameters
- providerFactory: ProviderFactory
Returns ConsentHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<never>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<never>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<never>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ConstantConverter
A RepresentationConverter that ensures -a representation for a certain content type is available.
-Representations of the same content type are served as is; -others are replaced by a constant document.
-This can for example be used to serve an index.html file, -which could then interactively load another representation.
-Options default to the most permissive values when not defined.
-Hierarchy (view full)
- RepresentationConverter
- ConstantConverter
Index
Constructors
Methods
Constructors
constructor
- new
Constant Converter(filePath, contentType, options?): ConstantConverter Creates a new constant converter.
-Parameters
- filePath: string
The path to the constant representation.
- - contentType: string
The content type of the constant representation.
- - options: ConstantConverterOptions = {}
Extra options for the converter.
-
Returns ConstantConverter
- filePath: string
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ConstantMetadataWriter
A MetadataWriter that takes a constant map of header names and values.
-Hierarchy (view full)
- MetadataWriter
- ConstantMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Constant Metadata Writer(headers): ConstantMetadataWriter Parameters
- headers: Record<string, string>
Returns ConstantMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
response: HttpResponse;
}Input that needs to be handled.
-response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class ContainerInitializer
Initializer that sets up a container. -Will copy all the files and folders in the given path to the corresponding documents and containers.
-Hierarchy (view full)
- Initializer
- ContainerInitializer
Index
Constructors
constructor
- new
Container Initializer(args): ContainerInitializer Parameters
- args: ContainerInitializerArgs
Returns ContainerInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class ContainerPathStorage<T>
A KeyValueStorage that prepends a relative path to the key. -Leading slashes of the relative path are trimmed, and a trailing slash is added if needed.
-Type Parameters
Hierarchy (view full)
- PassthroughKeyValueStorage<T>
- ContainerPathStorage
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Container Path Storage<T>(source, relativePath): ContainerPathStorage<T> Type Parameters
Parameters
- source: KeyValueStorage<string, T>
- relativePath: string
Returns ContainerPathStorage<T>
Methods
delete
entries
get
has
set
- set(key, value): Promise<ContainerPathStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: T
Value to store.
-
Returns Promise<ContainerPathStorage<T>>
The storage.
-- key: string
Protectedto
Protectedto
Class ContainerToTemplateConverter
A RepresentationConverter that creates a templated representation of a container.
-Hierarchy (view full)
- BaseTypedRepresentationConverter
- ContainerToTemplateConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Container To Template Converter(templateEngine, contentType, identifierStrategy): ContainerToTemplateConverter Parameters
- templateEngine: TemplateEngine<Dict<unknown>>
- contentType: string
- identifierStrategy: IdentifierStrategy
Returns ContainerToTemplateConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ContentLengthParser
Parser for the content-length header.
Hierarchy (view full)
- MetadataParser
- ContentLengthParser
Index
Constructors
constructor
- new
Content Length Parser(): ContentLengthParser Returns ContentLengthParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class ContentTypeMetadataWriter
Adds the Content-Type header containing value and parameters (if available).
Hierarchy (view full)
- MetadataWriter
- ContentTypeMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Content Type Metadata Writer(): ContentTypeMetadataWriter Returns ContentTypeMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class ContentTypeParser
Parser for the content-type header.
Hierarchy (view full)
- MetadataParser
- ContentTypeParser
Index
Constructors
Methods
Constructors
constructor
- new
Content Type Parser(): ContentTypeParser Returns ContentTypeParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class ContentTypeReplacer
A RepresentationConverter that changes the content type -but does not alter the representation.
-Useful for when a content type is binary-compatible with another one; -for instance, all JSON-LD files are valid JSON files.
-Hierarchy (view full)
- TypedRepresentationConverter
- ContentTypeReplacer
Index
Constructors
Methods
Constructors
constructor
- new
Content Type Replacer(replacements): ContentTypeReplacer Parameters
- replacements: Record<string, string>
Map of content type patterns and content types to replace them by.
-
Returns ContentTypeReplacer
- replacements: Record<string, string>
- new
Content Type Replacer(replacements): ContentTypeReplacer Parameters
- replacements: Record<string, Iterable<string>>
Returns ContentTypeReplacer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
get
- get
Output Types(contentType): Promise<ValuePreferences> Gets the output content types this converter can convert the input type to, mapped to a numerical priority.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(__namedParameters): Promise<Representation>
Changes the content type on the representation.
-Parameters
- __namedParameters: RepresentationConverterArgs
Returns Promise<Representation>
handle
- handle
Safe(args): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-
Class ContextDocumentLoader
First, checks whether a context is stored locally before letting the super class do a fetch.
-This can be used when converting JSON-LD with Comunica-related libraries, such as rdf-parse.
To use this, add this document loader to the options of the call
-using the KeysRdfParseJsonLd.documentLoader.name key.
-All extra keys get passed in the Comunica ActionContext
-and this is the key that is used to define the document loader.
-See https://github.com/rubensworks/rdf-parse.js/blob/master/lib/RdfParser.ts
-and https://github.com/comunica/comunica/blob/master/packages/actor-rdf-parse-jsonld/lib/ActorRdfParseJsonLd.ts
Hierarchy
- FetchDocumentLoader
- ContextDocumentLoader
Index
Constructors
Methods
Constructors
constructor
- new
Context Document Loader(contexts): ContextDocumentLoader Parameters
- contexts: Record<string, string>
Returns ContextDocumentLoader
Class ControlHandler
Creates an object with the keys matching those of the input controls,
-and the values being the results received by the matching values in the same input.
If source is defined, the controls will be added to the output of that handler after passing the input.
-In case the control keys conflict with a key already present in the resulting object,
-the results will be merged.
Hierarchy (view full)
- JsonInteractionHandler
- ControlHandler
Index
Constructors
Methods
Constructors
constructor
- new
Control Handler(controls, source?): ControlHandler Parameters
- controls: Record<string, InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>>
Optionalsource: JsonInteractionHandler<Dict<Json>>
Returns ControlHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Protectedgenerate
- generate
Control Set(input, value): Promise<undefined | Json> Parameters
- input: JsonInteractionHandlerInput
- value: InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>
Returns Promise<undefined | Json>
Protectedgenerate
- generate
Controls(input): Promise<Dict<Json>> Generate the controls for all the stored keys.
-Parameters
- input: JsonInteractionHandlerInput
Returns Promise<Dict<Json>>
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Protectedis
- is
Route(value): value is InteractionRoute<never> Parameters
- value: InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>
Returns value is InteractionRoute<never>
Protectedmerge
Class ConvertingErrorHandler
Converts an error into a Representation of content type internal/error. -Then feeds that representation into its converter to create a representation based on the given preferences.
-Hierarchy (view full)
- ErrorHandler
- ConvertingErrorHandler
Index
Constructors
Methods
Constructors
constructor
- new
Converting Error Handler(converter, preferenceParser, showStackTrace?): ConvertingErrorHandler Parameters
- converter: RepresentationConverter
- preferenceParser: PreferenceParser
- showStackTrace: boolean = false
Returns ConvertingErrorHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ErrorHandlerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ErrorHandlerArgs
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: ErrorHandlerArgs
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ErrorHandlerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Class ConvertingNotificationSerializer
Converts a serialization based on the provided accept feature value.
-In case none was provided no conversion takes place.
Hierarchy (view full)
- NotificationSerializer
- ConvertingNotificationSerializer
Index
Constructors
Methods
Constructors
constructor
- new
Converting Notification Serializer(source, converter): ConvertingNotificationSerializer Parameters
- source: NotificationSerializer
- converter: RepresentationConverter
Returns ConvertingNotificationSerializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationSerializerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationSerializerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: NotificationSerializerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationSerializerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
Class ConvertingOperationHttpHandler
An OperationHttpHandler that converts the response of its handler based on the Operation preferences. -If there are no preferences, or no data, the response will be returned as-is.
-Hierarchy (view full)
- OperationHttpHandler
- ConvertingOperationHttpHandler
Index
Constructors
Methods
Constructors
constructor
- new
Converting Operation Http Handler(converter, operationHandler): ConvertingOperationHttpHandler Parameters
- converter: RepresentationConverter
- operationHandler: OperationHttpHandler
Returns ConvertingOperationHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class ConvertingPatcher
A ConvertingPatcher converts a document to its intermediateType,
-sends the result to the wrapped patcher, and then converts back to its original type.
-No changes will take place if no intermediateType is provided.
In case there is no resource yet and a new one needs to be created,
-the result of the wrapped patcher will be converted to the provided defaultType.
-In case no defaultType is provided, the patcher output will be returned directly.
Hierarchy (view full)
- RepresentationPatcher<Representation>
- ConvertingPatcher
Index
Constructors
constructor
- new
Converting Patcher(patcher, converter, intermediateType?, defaultType?): ConvertingPatcher Parameters
- patcher: RepresentationPatcher<Representation>
Patcher that will be called with the Representation.
- - converter: RepresentationConverter
Converter that will be used to generate intermediate Representation.
- OptionalintermediateType: stringContent-type of the intermediate Representation if conversion is needed.
-OptionaldefaultType: stringContent-type in case a new resource gets created and needs to be converted.
-
Returns ConvertingPatcher
- patcher: RepresentationPatcher<Representation>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<Representation>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<Representation>
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<Representation>
Class ConvertingRouterRule
Rule that directs requests based on how the data would need to be converted.
-In case the given converter can convert the data to the requested type,
-it will be directed to the convertStore.
-Otherwise the defaultStore will be chosen.
In case there is no data and only an identifier the defaultStore will be checked
-if it contains the given identifier.
-If not, the convertStore will be returned.
Hierarchy (view full)
- RouterRule
- ConvertingRouterRule
Index
Constructors
Methods
Constructors
constructor
- new
Converting Router Rule(typedStores, defaultStore): ConvertingRouterRule Parameters
- typedStores: ConvertingStoreEntry[]
- defaultStore: ResourceStore
Returns ConvertingRouterRule
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<ResourceStore>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that needs to be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceStore> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class CookieInteractionHandler
Handles all the necessary steps for having cookies. -Refreshes the cookie expiration if there was a successful account interaction. -Adds the cookie and cookie expiration data to the output metadata, -unless it is already present in that metadata. -Checks the account settings to see if the cookie needs to be remembered.
-Hierarchy (view full)
- JsonInteractionHandler
- CookieInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Cookie Interaction Handler(source, accountStore, cookieStore): CookieInteractionHandler Parameters
- source: JsonInteractionHandler<Dict<Json>>
- accountStore: AccountStore
- cookieStore: CookieStore
Returns CookieInteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class CookieMetadataWriter
Generates the necessary Set-Cookie header if a cookie value is detected in the metadata.
-The keys of the input cookieMap should be the URIs of the predicates
-used in the metadata when the object is a cookie value.
-The value of the map are objects that contain the name of the cookie,
-and the URI that is used to store the expiration date in the metadata, if any.
-If no expiration date is found in the metadata, none will be set for the cookie,
-causing it to be a session cookie.
Hierarchy (view full)
- MetadataWriter
- CookieMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Cookie Metadata Writer(cookieMap): CookieMetadataWriter Parameters
- cookieMap: Record<string, {
expirationUri?: string;
name: string;
}>
Returns CookieMetadataWriter
- cookieMap: Record<string, {
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class CookieParser
Parses the cookie header and stores their values as metadata.
-The keys of the input cookieMap should be the cookie names,
-and the values the corresponding predicate that should be used to store the value in the metadata.
-The values of the cookies will be used as objects in the generated triples
Hierarchy (view full)
- MetadataParser
- CookieParser
Index
Constructors
Methods
Constructors
constructor
- new
Cookie Parser(cookieMap): CookieParser Parameters
- cookieMap: Record<string, string>
Returns CookieParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class CorsHandler
Handler that sets CORS options on the response.
-In case of an OPTIONS request this handler will close the connection after adding its headers
-if preflightContinue is set to false.
Solid, §8.1: "A server MUST implement the CORS protocol [FETCH] such that, to the extent possible, -the browser allows Solid apps to send any request and combination of request headers to the server, -and the Solid app can read any response and response headers received from the server." -Full details: https://solidproject.org/TR/2021/protocol-20211217#cors-server
-Hierarchy (view full)
- HttpHandler
- CorsHandler
Index
Constructors
Methods
Constructors
constructor
- new
Cors Handler(options?): CorsHandler Parameters
- options: SimpleCorsOptions = {}
Returns CorsHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class CreateAccountHandler
Creates new accounts using an AccountStore;
-Hierarchy (view full)
- ResolveLoginHandler
- CreateAccountHandler
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Create Account Handler(accountStore, cookieStore): CreateAccountHandler Parameters
- accountStore: AccountStore
- cookieStore: CookieStore
Returns CreateAccountHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(): Promise<JsonRepresentation<EmptyObject>> Returns Promise<JsonRepresentation<EmptyObject>>
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
login
- login(): Promise<JsonRepresentation<LoginOutputType>>
Takes the necessary steps to log a user in.
-Returns Promise<JsonRepresentation<LoginOutputType>>
Protectedupdate
- update
Remember Setting(accountId, remember?): Promise<void> Updates the account setting that determines whether the login status needs to be remembered.
-Parameters
- accountId: string
ID of the account.
- Optionalremember: booleanIf the account should be remembered or not. The setting will not be updated if this is undefined.
-
Returns Promise<void>
- accountId: string
Class CreateClientCredentialsHandler
Handles the creation of client credential tokens.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- CreateClientCredentialsHandler
Implements
Index
Constructors
constructor
- new
Create Client Credentials Handler(webIdStore, clientCredentialsStore, clientCredentialsRoute): CreateClientCredentialsHandler Parameters
- webIdStore: WebIdStore
- clientCredentialsStore: ClientCredentialsStore
- clientCredentialsRoute: ClientCredentialsIdRoute
Returns CreateClientCredentialsHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class CreateModesExtractor
Adds the create access mode to the result of the source in case the target resource does not exist.
Hierarchy (view full)
- ModesExtractor
- CreateModesExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Create Modes Extractor(source, resourceSet): CreateModesExtractor Parameters
- source: ModesExtractor
- resourceSet: ResourceSet
Returns CreateModesExtractor
Methods
can
- can
Handle(operation): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- operation: Operation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-
handle
- handle(operation): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- operation: Operation
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class CreatePasswordHandler
Handles the creation of email/password login combinations for an account.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- CreatePasswordHandler
Implements
Index
Constructors
constructor
- new
Create Password Handler(passwordStore, passwordRoute): CreatePasswordHandler Parameters
- passwordStore: PasswordStore
- passwordRoute: PasswordIdRoute
Returns CreatePasswordHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class CreatePodHandler
Handles the creation of pods. -Will call the stored PodCreator with the settings found in the input JSON.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- CreatePodHandler
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Create Pod Handler(podStore, podCreator, webIdLinkRoute, podIdRoute, allowRoot?): CreatePodHandler Parameters
- podStore: PodStore
- podCreator: PodCreator
- webIdLinkRoute: WebIdLinkRoute
- podIdRoute: PodIdRoute
- allowRoot: boolean = false
Returns CreatePodHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class CreatedResponseDescription
Corresponds to a 201 response, containing the relevant location metadata.
-Hierarchy (view full)
- ResponseDescription
- CreatedResponseDescription
Index
Constructors
Properties
Constructors
constructor
- new
Created Response Description(location): CreatedResponseDescription Parameters
- location: ResourceIdentifier
Returns CreatedResponseDescription
Class CredentialsExtractorAbstract
Responsible for extracting credentials from an incoming request.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Credentials Extractor(): CredentialsExtractor Returns CredentialsExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Abstracthandle
- handle(input): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpRequest
Input that needs to be handled.
-
Returns Promise<Credentials>
A promise resolving when handling is finished.
-- input: HttpRequest
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class DPoPWebIdExtractor
Credentials extractor that extracts a WebID from a DPoP-bound access token.
-Hierarchy (view full)
- CredentialsExtractor
- DPoPWebIdExtractor
Index
Constructors
constructor
- new DPoPWeb
Id Extractor(originalUrlExtractor): DPoPWebIdExtractor Parameters
- originalUrlExtractor: TargetExtractor
Reconstructs the original URL as requested by the client
-
Returns DPoPWebIdExtractor
- originalUrlExtractor: TargetExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(request): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- request: HttpRequest
Returns Promise<Credentials>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class DataAccessorBasedStore
ResourceStore which uses a DataAccessor for backend access.
-The DataAccessor interface provides elementary store operations such as read and write. -This DataAccessorBasedStore uses those elementary store operations -to implement the more high-level ResourceStore contact, abstracting all common functionality -such that new stores can be added by implementing the more simple DataAccessor contract. -DataAccessorBasedStore thereby provides behaviours for reuse across different stores, such as:
--
-
- Converting container metadata to data -
- Converting slug to URI -
- Checking if addResource target is a container -
- Checking if no containment triples are written to a container -
- etc. -
Currently "metadata" is seen as something that is not directly accessible. -That means that a consumer can't write directly to the metadata of a resource, only indirectly through headers. -(Except for containers where data and metadata overlap).
-The one thing this store does not take care of (yet?) are containment triples for containers
-Work has been done to minimize the number of required calls to the DataAccessor, -but the main disadvantage is that sometimes multiple calls are required where a specific store might only need one.
-Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Data Accessor Based Store(accessor, identifierStrategy, auxiliaryStrategy, metadataStrategy): DataAccessorBasedStore Parameters
- accessor: DataAccessor
- identifierStrategy: IdentifierStrategy
- auxiliaryStrategy: AuxiliaryStrategy
- metadataStrategy: AuxiliaryStrategy
Returns DataAccessorBasedStore
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
Protectedclean
Protectedcreate
- create
Recursive Containers(container): Promise<ChangeMap> Create containers starting from the root until the given identifier corresponds to an existing container. -Will throw errors if the identifier of the last existing "container" corresponds to an existing document.
-Parameters
- container: ResourceIdentifier
Identifier of the container which will need to exist.
-
Returns Promise<ChangeMap>
- container: ResourceIdentifier
Protectedcreate
- create
Safe Uri(container, metadata): Promise<ResourceIdentifier> Generate a valid URI to store a new Resource in the given container. -URI will be based on the slug header if there is one and is guaranteed to not exist yet.
-Parameters
- container: ResourceIdentifier
Identifier of the target container.
- - metadata: RepresentationMetadata
Metadata of the new resource.
-
Returns Promise<ResourceIdentifier>
- container: ResourceIdentifier
ProtectedcreateURI
- createURI(container, isContainer, slug?): ResourceIdentifier
Generates a new URI for a resource in the given container, potentially using the given slug.
-Solid, §5.3: "Servers MUST allow creating new resources with a POST request to URI path ending
-/. -Servers MUST create a resource with URI path ending/{id}in container/. -Servers MUST create a container with URI path ending/{id}/in container/for requests -including the HTTP Link header with rel="type" targeting a valid LDP container type." -https://solid.github.io/specification/protocol#writing-resourcesParameters
- container: ResourceIdentifier
Parent container of the new URI.
- - isContainer: boolean
Does the new URI represent a container?
- Optionalslug: stringSlug to use for the new URI.
-
Returns ResourceIdentifier
- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Protectedget
- get
Normalized Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata matching the identifier, ignoring the presence of a trailing slash or not.
-Solid, §3.1: "If two URIs differ only in the trailing slash, -and the server has associated a resource with one of them, -then the other URI MUST NOT correspond to another resource." -https://solid.github.io/specification/protocol#uri-slash-semantics
-First the identifier gets requested. If no result is found, -the identifier with differing trailing slash is requested.
-Parameters
- identifier: ResourceIdentifier
Identifier that needs to be checked.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Representation(identifier): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
Protectedget
- get
Safe Normalized Metadata(identifier): Promise<undefined | RepresentationMetadata> Returns the result of
-getNormalizedMetadataor undefined if a 404 error is thrown.Parameters
- identifier: ResourceIdentifier
Returns Promise<undefined | RepresentationMetadata>
Protectedhandle
- handle
Container Data(representation): Promise<void> Warns when the representation has data and removes the content-type from the metadata.
-Parameters
- representation: Representation
Container representation.
-
Returns Promise<void>
- representation: Representation
Protectedhas
Protectedhas
- has
Proper Children(container): Promise<boolean> Checks if the given container has any non-auxiliary resources.
-Parameters
- container: ResourceIdentifier
Returns Promise<boolean>
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
Protectedis
- is
Container Type(metadata): boolean Checks whether the given metadata represents a (potential) container, -based on the metadata.
-Parameters
- metadata: RepresentationMetadata
Metadata of the (new) resource.
-
Returns boolean
- metadata: RepresentationMetadata
Protectedis
- is
Root Storage(metadata): boolean Verifies if this is the metadata of a root storage container.
-Parameters
- metadata: RepresentationMetadata
Returns boolean
modify
- modify
Resource(identifier, patch, conditions?): Promise<never> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<never>
A ChangeMap.
-- identifier: ResourceIdentifier
Protectedremove
- remove
Response Metadata(metadata): void Removes all generated data from metadata to prevent it from being stored permanently.
-Parameters
- metadata: RepresentationMetadata
Returns void
Protectedsafely
- safely
Delete Auxiliary Resources(identifiers): Promise<ResourceIdentifier[]> Deletes the given array of auxiliary identifiers. -Does not throw an error if something goes wrong.
-Parameters
- identifiers: ResourceIdentifier[]
Returns Promise<ResourceIdentifier[]>
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Protectedupdate
- update
Container Modified Date(container): Promise<void> Updates the last modified date of the given container
-Parameters
- container: ResourceIdentifier
Returns Promise<void>
Protectedvalidate
- validate
Conditions(conditions?, metadata?): void Verify if the given metadata matches the conditions.
-Parameters
Optionalconditions: ConditionsOptionalmetadata: RepresentationMetadata
Returns void
Protectedvalidate
- validate
Identifier(identifier): void Verify if the given identifier matches the stored base.
-Parameters
- identifier: ResourceIdentifier
Returns void
Protectedvalidate
- validate
Slug(isContainer, slug?): void Validates if the slug and headers are valid. -Errors if slug exists, ends on slash, but ContainerType Link header is NOT present
-Parameters
- isContainer: boolean
Is the slug supposed to represent a container?
- Optionalslug: stringIs the requested slug (if any).
-
Returns void
- isContainer: boolean
Protectedwrite
- write
Data(identifier, representation, isContainer, createContainers, exists): Promise<ChangeMap> Write the given resource to the DataAccessor. Metadata will be updated with necessary triples. -For containers,
-handleContainerDatawill be used to verify the data.Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - representation: Representation
Corresponding Representation.
- - isContainer: boolean
Is the incoming resource a container?
- - createContainers: boolean
Should parent containers (potentially) be created?
- - exists: boolean
If the resource already exists.
-
Returns Promise<ChangeMap>
Identifiers of resources that were possibly modified.
-- identifier: ResourceIdentifier
Protectedwrite
- write
Metadata(identifier, representation): Promise<ChangeMap> Write the given metadata resource to the DataAccessor.
-Parameters
- identifier: ResourceIdentifier
Identifier of the metadata.
- - representation: Representation
Corresponding Representation.
-
Returns Promise<ChangeMap>
Identifiers of resources that were possibly modified.
-- identifier: ResourceIdentifier
Class DeleteClientCredentialsHandler
Handles the deletion of client credentials tokens.
-Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- DeleteClientCredentialsHandler
Index
Constructors
Methods
Constructors
constructor
- new
Delete Client Credentials Handler(clientCredentialsStore, clientCredentialsRoute): DeleteClientCredentialsHandler Parameters
- clientCredentialsStore: ClientCredentialsStore
- clientCredentialsRoute: ClientCredentialsIdRoute
Returns DeleteClientCredentialsHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class DeleteNotificationGenerator
Generates a Notification for a resource that was deleted. -This differs from other activity notifications in that there is no state and no resource metadata -since the resource no longer exists.
-Hierarchy (view full)
- NotificationGenerator
- DeleteNotificationGenerator
Index
Constructors
Methods
Constructors
constructor
- new
Delete Notification Generator(): DeleteNotificationGenerator Returns DeleteNotificationGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<Notification>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<Notification>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<Notification> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Notification>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class DeleteOperationHandler
Handles DELETE Operations. -Calls the deleteResource function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- DeleteOperationHandler
Index
Constructors
Methods
Constructors
constructor
- new
Delete Operation Handler(store): DeleteOperationHandler Parameters
- store: ResourceStore
Returns DeleteOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class DeleteParentExtractor
In case a resource is being deleted but does not exist, -the server response code depends on the access modes the agent has on the parent container. -In case the agent has read access on the parent container, a 404 should be returned, -otherwise it should be 401/403.
-This class adds support for this by requiring read access on the parent container -in case the target resource does not exist.
-Hierarchy (view full)
- ModesExtractor
- DeleteParentExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Delete Parent Extractor(source, resourceSet, identifierStrategy): DeleteParentExtractor Parameters
- source: ModesExtractor
- resourceSet: ResourceSet
- identifierStrategy: IdentifierStrategy
Returns DeleteParentExtractor
Methods
can
- can
Handle(operation): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- operation: Operation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-
handle
- handle(operation): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- operation: Operation
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class DeletePasswordHandler
Handles the deletion of a password login method.
-Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- DeletePasswordHandler
Index
Constructors
Methods
Constructors
constructor
- new
Delete Password Handler(passwordStore, passwordRoute): DeletePasswordHandler Parameters
- passwordStore: PasswordStore
- passwordRoute: PasswordIdRoute
Returns DeletePasswordHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class DynamicJsonToTemplateConverter
Converts JSON data by using it as input parameters for rendering a template.
-The extension field can be used to only support a specific type of templates,
-such as ".ejs" for EJS templates.
To find the templates it expects the Representation metadata to contain SOLID_META.template triples,
-with the objects being the template paths.
-For each of those templates there also needs to be a CONTENT_TYPE triple
-describing the content-type of that template.
The output of the result depends on the content-type matched with the template. -In case JSON is the most preferred output type, -the input representation will be returned unless a JSON template is defined.
-Hierarchy (view full)
- RepresentationConverter
- DynamicJsonToTemplateConverter
Index
Constructors
Methods
Constructors
constructor
- new
Dynamic Json To Template Converter(templateEngine): DynamicJsonToTemplateConverter Parameters
- templateEngine: TemplateEngine<Dict<unknown>>
Returns DynamicJsonToTemplateConverter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class EjsTemplateEngine<T>
Fills in EJS templates.
-Type Parameters
Hierarchy (view full)
- ExtensionBasedTemplateEngine<T>
- EjsTemplateEngine
Index
Constructors
constructor
- new
Ejs Template Engine<T>(baseUrl, supportedExtensions?): EjsTemplateEngine<T> Type Parameters
Parameters
- baseUrl: string
Base URL of the server.
- - supportedExtensions: string[] = ...
The extensions that are supported by this template engine (defaults to 'ejs').
-
Returns EjsTemplateEngine<T>
- baseUrl: string
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
handle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class EmailSenderAbstract
A class that can send an e-mail.
-Hierarchy (view full)
- AsyncHandler<EmailArgs>
- EmailSender
Index
Constructors
Methods
Constructors
constructor
- new
Email Sender(): EmailSender Returns EmailSender
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: EmailArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: EmailArgs
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: EmailArgs
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: EmailArgs
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: EmailArgs
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: EmailArgs
Class EqualReadWriteLocker
A ReadWriteLocker that gives no priority to read or write operations: both use the same lock.
-Hierarchy (view full)
- EqualReadWriteLocker
Implements
Index
Constructors
constructor
- new
Equal Read Write Locker(locker): EqualReadWriteLocker Parameters
- locker: ResourceLocker
Returns EqualReadWriteLocker
Methods
Protectedwith
- with
Lock<T>(identifier, whileLocked): Promise<T> Acquires a new lock for the requested identifier. -Will resolve when the input function resolves.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
Function to resolve while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Class ErrorHandlerAbstract
Converts an error into a ResponseDescription based on the request preferences.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Error Handler(): ErrorHandler Returns ErrorHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ErrorHandlerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Abstracthandle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ErrorHandlerArgs
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: ErrorHandlerArgs
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ErrorHandlerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Class ErrorToJsonConverter
Converts an Error object to JSON by copying its fields.
-Hierarchy (view full)
- BaseTypedRepresentationConverter
- ErrorToJsonConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Error To Json Converter(): ErrorToJsonConverter Returns ErrorToJsonConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ErrorToQuadConverter
Converts an error object into quads by creating a triple for each of name/message/stack.
-Hierarchy (view full)
- BaseTypedRepresentationConverter
- ErrorToQuadConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Error To Quad Converter(): ErrorToQuadConverter Returns ErrorToQuadConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ErrorToTemplateConverter
Serializes an Error by filling in the provided template. -Content-type is based on the constructor parameter.
-In case the input Error has an errorCode value,
-the converter will look in the descriptions for a file
-with the exact same name as that error code + extension.
-The templating engine will then be applied to that file.
-That result will be passed as an additional parameter to the main templating call,
-using the variable codeMessage.
Hierarchy (view full)
- BaseTypedRepresentationConverter
- ErrorToTemplateConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Error To Template Converter(templateEngine, templateOptions?): ErrorToTemplateConverter Parameters
- templateEngine: TemplateEngine<Dict<unknown>>
OptionaltemplateOptions: TemplateOptions
Returns ErrorToTemplateConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class ExpiringAdapter
An IDP storage adapter that uses an ExpiringStorage -to persist data.
-Implements
- Adapter
Index
Constructors
constructor
- new
Expiring Adapter(name, storage): ExpiringAdapter Parameters
- name: string
- storage: ExpiringStorage<string, unknown>
Returns ExpiringAdapter
Class ExpiringAdapterFactory
The factory for a ExpiringStorageAdapter
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Expiring Adapter Factory(storage): ExpiringAdapterFactory Parameters
- storage: ExpiringStorage<string, unknown>
Returns ExpiringAdapterFactory
Methods
create
- create
Storage Adapter(name): ExpiringAdapter Parameters
- name: string
Returns ExpiringAdapter
Class ExtensionBasedMapper
Supports the behaviour described in https://www.w3.org/DesignIssues/HTTPFilenameMapping.html -Determines content-type based on the file extension. -In case an identifier does not end on an extension matching its content-type, -the corresponding file will be appended with the correct extension, preceded by $.
-Hierarchy (view full)
- BaseFileIdentifierMapper
- ExtensionBasedMapper
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Extension Based Mapper(base, rootFilepath, customTypes?): ExtensionBasedMapper Parameters
- base: string
- rootFilepath: string
OptionalcustomTypes: Record<string, string>
Returns ExtensionBasedMapper
Properties
Protected Readonlybase
Protected Readonlylogger
Protected Readonlyroot
Protected Readonlyunknown
Methods
Protectedget
Protectedget
Protectedget
Protectedget
- get
Content Type From Url(identifier, contentType?): Promise<string> Determines the content type from the document identifier.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<string>
The content type of the document.
-- identifier: ResourceIdentifier
Protectedget
Protectedget
- get
Relative Path(identifier): string Strips the baseRequestURI from the identifier.
-Parameters
- identifier: ResourceIdentifier
Incoming identifier.
-
Returns string
A string representing the relative path.
-- identifier: ResourceIdentifier
Protectedis
map
- map
File Path To Url(filePath, isContainer): Promise<ResourceLink> Maps the given file path to a URL and determines its content type.
-Parameters
- filePath: string
The input file path.
- - isContainer: boolean
If the path corresponds to a file.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- filePath: string
Protectedmap
- map
Url To Container Path(identifier, filePath): Promise<ResourceLink> Maps the given container identifier to a file path, -possibly making alterations to the direct translation.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedmap
- map
Url To Document Path(identifier, filePath, contentType?): Promise<ResourceLink> Maps the given document identifier to a file path, -possibly making alterations to the direct translation -(for instance, based on its content type)). -Determines the content type if none was provided.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
map
- map
Url To File Path(identifier, isMetadata, contentType?): Promise<ResourceLink> Maps the given resource identifier / URL to a file path. -Determines the content type if none was provided. -For containers the content-type input is ignored.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - isMetadata: boolean
If we need the data or metadata file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedstrip
Protectedvalidate
- validate
Relative Path(path, identifier): void Check whether the given relative path is valid.
-Parameters
- path: string
A relative path, as generated by getRelativePath.
- - identifier: ResourceIdentifier
A resource identifier.
-
Returns void
- path: string
Class ExtensionBasedMapperFactory
Factory that can create FileIdentifierMappers so the base and rootFilePath can be set dynamically. -Specifically used when identifiers need to be generated for a new pod (since pod identifiers are generated).
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Extension Based Mapper Factory(): ExtensionBasedMapperFactory Returns ExtensionBasedMapperFactory
Methods
create
- create(base, rootFilePath): Promise<ExtensionBasedMapper>
Parameters
- base: string
- rootFilePath: string
Returns Promise<ExtensionBasedMapper>
Class ExtensionBasedTemplateEngine<T>Abstract
Parent class for template engines that accept handling based on whether the template extension is supported.
-Type Parameters
Hierarchy (view full)
- TemplateEngine<T>
- ExtensionBasedTemplateEngine
Index
Constructors
Protectedconstructor
- new
Extension Based Template Engine<T>(supportedExtensions): ExtensionBasedTemplateEngine<T> Constructor for ExtensionBasedTemplateEngine.
-Type Parameters
Parameters
- supportedExtensions: string[]
Array of the extensions supported by the template engine (e.g. [ 'ejs' ]).
-
Returns ExtensionBasedTemplateEngine<T>
- supportedExtensions: string[]
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Abstracthandle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class FileDataAccessor
DataAccessor that uses the file system to store documents as files and containers as folders.
-Hierarchy (view full)
- FileDataAccessor
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
File Data Accessor(resourceMapper): FileDataAccessor Parameters
- resourceMapper: FileIdentifierMapper
Returns FileDataAccessor
Methods
can
- can
Handle(representation): Promise<void> Only binary data can be directly stored as files so will error on non-binary data.
-Parameters
- representation: Representation
Returns Promise<void>
delete
- delete
Resource(identifier): Promise<void> Removes the corresponding file/folder (and metadata file).
-Parameters
- identifier: ResourceIdentifier
Returns Promise<void>
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Will return data stream directly to the file corresponding to the resource. -Will throw NotFoundHttpError if the input is a container.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<Guarded<Readable>>
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Will return corresponding metadata by reading the metadata file (if it exists) -and adding file system specific metadata elements.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<RepresentationMetadata>
Protectedget
Protectedverify
- verify
Existing Extension(link): Promise<void> Verifies if there already is a file corresponding to the given resource. -If yes, that file is removed if it does not match the path given in the input ResourceLink. -This can happen if the content-type differs from the one that was stored.
-Parameters
- link: ResourceLink
ResourceLink corresponding to the new resource data.
-
Returns Promise<void>
- link: ResourceLink
write
- write
Container(identifier, metadata): Promise<void> Creates corresponding folder if necessary and writes metadata to metadata file if necessary.
-Parameters
- identifier: ResourceIdentifier
- metadata: RepresentationMetadata
Returns Promise<void>
Protectedwrite
write
- write
Document(identifier, data, metadata): Promise<void> Writes the given data as a file (and potential metadata as additional file). -The metadata file will be written first and will be deleted if something goes wrong writing the actual data.
-Parameters
- identifier: ResourceIdentifier
- data: Guarded<Readable>
- metadata: RepresentationMetadata
Returns Promise<void>
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Protectedwrite
- write
Metadata File(link, metadata): Promise<boolean> Writes the metadata of the resource to a meta file.
-Parameters
- link: ResourceLink
Path related metadata of the resource.
- - metadata: RepresentationMetadata
Metadata to write.
-
Returns Promise<boolean>
True if data was written to a file.
-- link: ResourceLink
Class FileSizeReporter
SizeReporter that is used to calculate sizes of resources for a file based system.
-Implements
- SizeReporter<string>
Index
Constructors
Methods
Constructors
constructor
- new
File Size Reporter(fileIdentifierMapper, rootFilePath, ignoreFolders?): FileSizeReporter Parameters
- fileIdentifierMapper: FileIdentifierMapper
- rootFilePath: string
OptionalignoreFolders: string[]
Returns FileSizeReporter
Methods
calculate
estimate
- estimate
Size(metadata): Promise<undefined | number> The estimated size of a resource in this reporter is simply the content-length header
-Parameters
- metadata: RepresentationMetadata
Returns Promise<undefined | number>
get
- get
Size(identifier): Promise<Size> Returns the size of the given resource ( and its children ) in bytes
-Parameters
- identifier: ResourceIdentifier
Returns Promise<Size>
get
Class FileSystemResourceLocker
A resource locker making use of the proper-lockfile library. -Note that no locks are kept in memory, thus this is considered thread- and process-safe. -While it stores the actual locks on disk, it also tracks them in memory for when they need to be released. -This means only the worker thread that acquired a lock can release it again, -making this implementation unusable in combination with a wrapping read/write lock implementation.
-This proper-lockfile library has its own retry mechanism for the operations, since a lock/unlock call will -either resolve successfully or reject immediately with the causing error. The retry function of the library -however will be ignored and replaced by our own LockUtils' retryFunction function.
-Implements
Index
Constructors
constructor
- new
File System Resource Locker(args): FileSystemResourceLocker Create a new FileSystemResourceLocker
-Parameters
- args: FileSystemResourceLockerArgs
Configures the locker using the specified FileSystemResourceLockerArgs instance.
-
Returns FileSystemResourceLocker
- args: FileSystemResourceLockerArgs
Methods
acquire
- acquire(identifier): Promise<void>
Acquires a lock on the requested identifier. -The promise will resolve when the lock has been acquired.
-Parameters
- identifier: ResourceIdentifier
Resource to acquire a lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
finalize
initialize
- initialize(): Promise<void>
Initializer method to be executed on server start. This makes sure that no pre-existing (dangling) locks -remain on disk, so that request will not be blocked because a lock was acquired in the previous server instance.
-NOTE: this also removes locks created by the GreedyReadWriteLocker. -(See issue: https://github.com/CommunitySolidServer/CommunitySolidServer/issues/1358)
-Returns Promise<void>
release
- release(identifier): Promise<void>
Releases a lock on the requested identifier. -The promise will resolve when the lock has been released. -If there is no lock on the resource, an error should be thrown.
-Parameters
- identifier: ResourceIdentifier
Resource to release the lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class FilterMetadataDataAccessor
A FilterMetadataDataAccessor wraps a DataAccessor such that specific metadata properties -can be filtered before passing on the call to the wrapped DataAccessor.
-Hierarchy (view full)
- PassthroughDataAccessor
- FilterMetadataDataAccessor
Index
Constructors
constructor
- new
Filter Metadata Data Accessor(accessor, filters): FilterMetadataDataAccessor Construct an instance of FilterMetadataDataAccessor.
-Parameters
- accessor: DataAccessor
The DataAccessor to wrap.
- - filters: FilterPattern[]
Filter patterns to be used for metadata removal.
-
Returns FilterMetadataDataAccessor
- accessor: DataAccessor
Methods
can
- can
Handle(representation): Promise<void> Should throw a NotImplementedHttpError if the DataAccessor does not support storing the given Representation.
-Parameters
- representation: Representation
Incoming Representation.
-
Returns Promise<void>
- representation: Representation
delete
- delete
Resource(identifier): Promise<void> Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata corresponding to the identifier. -If possible, it is suggested to add a
-posix:sizetriple to the metadata indicating the binary size. -This is necessary for range requests.Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
- write
Container(identifier, metadata): Promise<void> Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Document(identifier, data, metadata): Promise<void> Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class FilterPattern
Represents a triple pattern to be used as a filter.
- Index
Constructors
Properties
Constructors
constructor
- new
Filter Pattern(subject?, predicate?, object?): FilterPattern Parameters
Optionalsubject: stringOptionally filter based on a specific subject.
-Optionalpredicate: stringOptionally filter based on a predicate.
-Optionalobject: stringOptionally filter based on a specific object.
-
Returns FilterPattern
Class FinalizableHandler
Allows using a Finalizable as a Finalizer Handler.
-Hierarchy (view full)
- Finalizer
- FinalizableHandler
Index
Constructors
constructor
- new
Finalizable Handler(finalizable): FinalizableHandler Parameters
- finalizable: Finalizable
Returns FinalizableHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class FinalizerAbstract
Finalizer is used to indicate an AsyncHandler that performs finalization logic.
-Hierarchy (view full)
- AsyncHandler
- Finalizer
Index
Constructors
Methods
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: void
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: void
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class FixedContentTypeMapper
A mapper that always returns a fixed content type for files.
-Hierarchy (view full)
- BaseFileIdentifierMapper
- FixedContentTypeMapper
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Fixed Content Type Mapper(base, rootFilepath, contentType, pathSuffix?, urlSuffix?): FixedContentTypeMapper Parameters
- base: string
Base URL.
- - rootFilepath: string
Base file path.
- - contentType: string
Fixed content type that will be used for all resources.
- - pathSuffix: string = ''
An optional suffix that will be appended to all file paths. -Requested file paths without this suffix will be rejected.
- - urlSuffix: string = ''
An optional suffix that will be appended to all URL. -Requested URLs without this suffix will be rejected.
-
Returns FixedContentTypeMapper
- base: string
Properties
Protected Readonlybase
Protected Readonlycontent
Protected Readonlylogger
Protected Readonlypath
Protected Readonlyroot
Protected Readonlyunknown
Protected Readonlyurl
Methods
Protectedget
Protectedget
Protectedget
Protectedget
- get
Content Type From Url(identifier, contentType?): Promise<string> Determines the content type from the document identifier.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<string>
The content type of the document.
-- identifier: ResourceIdentifier
Protectedget
Protectedget
- get
Relative Path(identifier): string Strips the baseRequestURI from the identifier.
-Parameters
- identifier: ResourceIdentifier
Incoming identifier.
-
Returns string
A string representing the relative path.
-- identifier: ResourceIdentifier
Protectedis
map
- map
File Path To Url(filePath, isContainer): Promise<ResourceLink> Maps the given file path to a URL and determines its content type.
-Parameters
- filePath: string
The input file path.
- - isContainer: boolean
If the path corresponds to a file.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- filePath: string
Protectedmap
- map
Url To Container Path(identifier, filePath): Promise<ResourceLink> Maps the given container identifier to a file path, -possibly making alterations to the direct translation.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
map
- map
Url To Document Path(identifier, filePath, contentType?): Promise<ResourceLink> Maps the given document identifier to a file path, -possibly making alterations to the direct translation -(for instance, based on its content type)). -Determines the content type if none was provided.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
map
- map
Url To File Path(identifier, isMetadata, contentType?): Promise<ResourceLink> Maps the given resource identifier / URL to a file path. -Determines the content type if none was provided. -For containers the content-type input is ignored.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - isMetadata: boolean
If we need the data or metadata file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedvalidate
- validate
Relative Path(path, identifier): void Check whether the given relative path is valid.
-Parameters
- path: string
A relative path, as generated by getRelativePath.
- - identifier: ResourceIdentifier
A resource identifier.
-
Returns void
- path: string
Class ForbiddenHttpError
An error thrown when an agent is not allowed to access data.
-Hierarchy
- BaseHttpError
- ForbiddenHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Forbidden Http Error(message?, options?): ForbiddenHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns ForbiddenHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class ForgetWebIdHandler
Forgets the chosen WebID in an OIDC interaction, -causing the next policy trigger to be one where a new WebID has to be chosen.
-Hierarchy (view full)
- JsonInteractionHandler<never>
- ForgetWebIdHandler
Index
Constructors
Methods
Constructors
constructor
- new
Forget Web Id Handler(providerFactory): ForgetWebIdHandler Parameters
- providerFactory: ProviderFactory
Returns ForgetWebIdHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<never>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<never>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ForgotPasswordHandler
Responsible for the case where a user forgot their password and asks for a reset. -Will send out the necessary mail if the email address is known. -The JSON response will always be the same to prevent leaking which email addresses are stored.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- ForgotPasswordHandler
Implements
Index
Constructors
constructor
- new
Forgot Password Handler(args): ForgotPasswordHandler Parameters
Returns ForgotPasswordHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(): Promise<JsonRepresentation<Dict<Json>>> Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(__namedParameters): Promise<JsonRepresentation<OutType>>
Generates a record to reset the password for the given email address and then mails it. -In case there is no account, no error wil be thrown for privacy reasons. -Nothing will happen instead.
-Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<OutType>>
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class FormToJsonConverter
Converts application/x-www-form-urlencoded data to application/json. -Due to the nature of form data, the result will be a simple key/value JSON object.
-Hierarchy (view full)
- BaseTypedRepresentationConverter
- FormToJsonConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Form To Json Converter(): FormToJsonConverter Returns FormToJsonConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class FoundHttpError
Error used for resources that have been moved temporarily. -Methods other than GET may or may not be changed to GET in subsequent requests.
-Hierarchy
- BaseHttpError
- FoundHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Found Http Error(location, message?, options?): FoundHttpError Parameters
- location: string
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns FoundHttpError
Properties
Optional Readonlycause
Readonlyerror
Readonlylocation
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class GeneratedPodManager
Pod manager that uses an IdentifierGenerator and ResourcesGenerator -to create the default resources and identifier for a new pod.
-Implements
Index
Constructors
constructor
- new
Generated Pod Manager(store, resourcesGenerator): GeneratedPodManager Parameters
- store: ResourceStore
- resourcesGenerator: ResourcesGenerator
Returns GeneratedPodManager
Methods
create
- create
Pod(settings, overwrite): Promise<void> Creates a new pod, pre-populating it with the resources created by the data generator. -Will throw an error if the given identifier already has a resource.
-Parameters
- settings: PodSettings
- overwrite: boolean
Returns Promise<void>
Class GetOperationHandler
Handles GET Operations. -Calls the getRepresentation function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- GetOperationHandler
Index
Constructors
Methods
Constructors
constructor
- new
Get Operation Handler(store, eTagHandler): GetOperationHandler Parameters
- store: ResourceStore
- eTagHandler: ETagHandler
Returns GetOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class GlobalQuotaStrategy
The GlobalQuotaStrategy sets a limit on the amount of data stored on the server globally.
-Hierarchy (view full)
- QuotaStrategy
- GlobalQuotaStrategy
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Global Quota Strategy(limit, reporter, base): GlobalQuotaStrategy Parameters
- limit: Size
- reporter: SizeReporter<unknown>
- base: string
Returns GlobalQuotaStrategy
Methods
create
- create
Quota Guard(identifier): Promise<Guarded<PassThrough>> Get a Passthrough stream that will keep track of the available space. -If the quota is exceeded the stream will emit an error and destroy itself. -Like other Passthrough instances this will simply pass on the chunks, when the quota isn't exceeded.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource in question
-
Returns Promise<Guarded<PassThrough>>
a Passthrough instance that errors when quota is exceeded
-- identifier: ResourceIdentifier
estimate
- estimate
Size(metadata): Promise<undefined | Size> Get an estimated size of the resource
-Parameters
- metadata: RepresentationMetadata
the metadata that might include the size
-
Returns Promise<undefined | Size>
a Size object containing the estimated size and unit of the resource
-- metadata: RepresentationMetadata
get
- get
Available Space(identifier): Promise<Size> Get the available space when writing data to the given identifier. -If the given resource already exists it will deduct the already taken up -space by that resource since it is going to be overwritten and thus counts -as available space.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource of which you want the available space
-
Returns Promise<Size>
the available space and the unit of the space as a Size object
-- identifier: ResourceIdentifier
Protectedget
Class GreedyReadWriteLocker
A BaseReadWriteLocker that uses the same locker for the main lock and the count lock, -and uses a KeyValueStorage for keeping track of the counter.
-Since it is completely dependent on other implementations, -this locker is threadsafe if its inputs are as well.
-Hierarchy (view full)
- BaseReadWriteLocker
- GreedyReadWriteLocker
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Greedy Read Write Locker(locker, storage, readSuffix?, countSuffix?): GreedyReadWriteLocker Parameters
- locker: ResourceLocker
Used for creating read and write locks.
- - storage: KeyValueStorage<string, number>
Used for storing the amount of active read operations on a resource.
- - readSuffix: string = 'read'
Used to generate the identifier for the lock that is applied when updating the counter.
- - countSuffix: string = 'count'
Used to generate the identifier that will be used in the storage for storing the counter.
-
Returns GreedyReadWriteLocker
- locker: ResourceLocker
Properties
Protected Readonlycount
Protected Readonlycount
Protected Readonlylocker
Protected Readonlyread
Protected Readonlystorage
Methods
Protectedget
- get
Count Key(identifier): string This key is used for storing the count of active read operations.
-Parameters
- identifier: ResourceIdentifier
Returns string
Protectedget
- get
Count Lock Identifier(identifier): ResourceIdentifier Generate the identifier that will be used to acquire the count lock for the given identifier. -There will be cases where this lock needs to be acquired -while an active lock on the main resource is still being maintained. -This means that if the input
-resourceLockerandcountLockeruse the same locking system -this generated identifier needs to be different.Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
Protectedmodify
- modify
Count(identifier, mod): Promise<number> Updates the count with the given modifier. -Creates the data if it didn't exist yet. -Deletes the data when the count reaches zero.
-Parameters
- identifier: ResourceIdentifier
- mod: number
Returns Promise<number>
Protectedwith
- with
Lock<T>(identifier, whileLocked): Promise<T> Acquires a new lock for the requested identifier. -Will resolve when the input function resolves.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
Function to resolve while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Class HandlebarsTemplateEngine<T>
Fills in Handlebars templates.
-Type Parameters
Hierarchy (view full)
- ExtensionBasedTemplateEngine<T>
- HandlebarsTemplateEngine
Index
Constructors
constructor
- new
Handlebars Template Engine<T>(baseUrl, supportedExtensions?): HandlebarsTemplateEngine<T> Type Parameters
Parameters
- baseUrl: string
Base URL of the server.
- - supportedExtensions: string[] = ...
The extensions that are supported by this template engine (defaults to 'hbs').
-
Returns HandlebarsTemplateEngine<T>
- baseUrl: string
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
handle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class HandlerServerConfigurator
A ServerConfigurator that attaches an HttpHandler to the request event of a Server.
-All incoming requests will be sent to the provided handler.
-Failsafes are added to make sure a valid response is sent in case something goes wrong.
The showStackTrace parameter can be used to add stack traces to error outputs.
Hierarchy (view full)
- ServerConfigurator
- HandlerServerConfigurator
Index
Constructors
constructor
- new
Handler Server Configurator(handler, showStackTrace?): HandlerServerConfigurator Parameters
- handler: HttpHandler
- showStackTrace: boolean = false
Returns HandlerServerConfigurator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
Protected Readonlyerror
handle
- handle(server): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- server: Server<typeof IncomingMessage, typeof ServerResponse>
Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
Class HashEncodingStorage<T>
Encodes the input key with SHA-256 hashing, -to make sure there are no invalid or special path characters.
-This class was created specifically to prevent the issue of identifiers being too long when storing data: -https://github.com/CommunitySolidServer/CommunitySolidServer/issues/1013
-This should eventually be replaced by a more structural approach once internal storage has been refactored -and data migration from older versions and formats is supported.
-Type Parameters
Hierarchy (view full)
- PassthroughKeyValueStorage<T>
- HashEncodingStorage
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Hash Encoding Storage<T>(source): HashEncodingStorage<T> Type Parameters
Parameters
- source: KeyValueStorage<string, T>
Returns HashEncodingStorage<T>
Methods
delete
entries
get
has
set
- set(key, value): Promise<HashEncodingStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: T
Value to store.
-
Returns Promise<HashEncodingStorage<T>>
The storage.
-- key: string
Protectedto
Protectedto
Class HashMap<TKey, TVal>
A Map implementation that maps the Key object to a string using the provided hash function. -This ensures that equal objects that are not the same instance are mapped to the same value.
-Type Parameters
Hierarchy (view full)
- HashMap
Implements
Index
Methods
[iterator]
clear
delete
- delete(key): boolean
Parameters
- key: TKey
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.
-
entries
for
get
- get(key): undefined | TVal
Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
-Parameters
- key: TKey
Returns undefined | TVal
Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
-
has
- has(key): boolean
Parameters
- key: TKey
Returns boolean
boolean indicating whether an element with the specified key exists or not.
-
keys
set
values
Class HeadOperationHandler
Handles HEAD Operations. -Calls the getRepresentation function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- HeadOperationHandler
Index
Constructors
Methods
Constructors
constructor
- new
Head Operation Handler(store, eTagHandler): HeadOperationHandler Parameters
- store: ResourceStore
- eTagHandler: ETagHandler
Returns HeadOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class HeaderHandler
Handler that sets custom headers on the response.
-Hierarchy (view full)
- HttpHandler
- HeaderHandler
Index
Constructors
Methods
Constructors
constructor
- new
Header Handler(headers): HeaderHandler Parameters
- headers: Record<string, string>
Returns HeaderHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
response: HttpResponse;
}Input that needs to be handled.
-response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class HtmlViewEntry
Used to link file paths and URLs together. -The reason we use a separate object instead of a key/value Record, -is that this makes it easier to override the values in Components.js, -which can be useful if someone wants to replace the HTML for certain URLs.
- Index
Constructors
Properties
Constructors
constructor
- new
Html View Entry(route, filePath): HtmlViewEntry Parameters
- route: InteractionRoute<never>
- filePath: string
Returns HtmlViewEntry
Class HtmlViewHandler
Stores the HTML templates associated with specific InteractionRoutes.
-This class will only handle GET operations for which there is a matching template, -if HTML is more preferred than JSON. -The reason for doing it like this instead of a standard content negotiation flow, -is because we only want to return the HTML pages on GET requests.
-Templates will receive the parameter idpIndex in their context pointing to the root index URL of the IDP API
-and an authenticating parameter indicating if this is an active OIDC interaction.
Hierarchy (view full)
- InteractionHandler
- HtmlViewHandler
Index
Constructors
Methods
Constructors
constructor
- new
Html View Handler(index, templateEngine, templates): HtmlViewHandler Parameters
- index: InteractionRoute<never>
- templateEngine: TemplateEngine<Dict<unknown>>
- templates: HtmlViewEntry[]
Returns HtmlViewHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: InteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: InteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: InteractionHandlerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: InteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
Class HttpError<T>
A class for all errors that could be thrown by Solid. -All errors inheriting from this should fix the status code thereby hiding the HTTP internals from other components.
-Type Parameters
Hierarchy (view full)
- Error
- HttpError
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Http Error<T>(statusCode, name, message?, options?): HttpError<T> Creates a new HTTP error. Subclasses should call this with their fixed status code.
-Type Parameters
Parameters
- statusCode: T
HTTP status code needed for the HTTP response.
- - name: string
Error name. Useful for logging and stack tracing.
- Optionalmessage: stringError message.
-- options: HttpErrorOptions = {}
Optional options.
-
Returns HttpError<T>
- statusCode: T
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Optionalprepare
Optional override for formatting stack traces
-Staticstack
Class HttpHandlerAbstract
An HTTP request handler.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Http Handler(): HttpHandler Returns HttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class IdInteractionRoute<TBase, TId>
An InteractionRoute for routes that have a dynamic identifier in their path.
-Type Parameters
Hierarchy (view full)
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Id Interaction Route<TBase, TId>(base, idName, ensureSlash?): IdInteractionRoute<TBase, TId> Type Parameters
Parameters
- base: InteractionRoute<TBase>
- idName: TId
- ensureSlash: boolean = true
Returns IdInteractionRoute<TBase, TId>
Methods
get
match
- match
Path(path): undefined | Record<TBase | TId, string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<TBase | TId, string>
- path: string
Class IdentifierMap<T>
A specific implementation of HashMap where the key type is ResourceIdentifier.
-Type Parameters
Hierarchy (view full)
- HashMap<ResourceIdentifier, T>
- IdentifierMap
Index
Constructors
constructor
- new
Identifier Map<T>(iterable?): IdentifierMap<T> Type Parameters
Parameters
Optionaliterable: Iterable<readonly [ResourceIdentifier, T]>
Returns IdentifierMap<T>
Methods
[iterator]
- [iterator](): IterableIterator<[ResourceIdentifier, T]>
Returns IterableIterator<[ResourceIdentifier, T]>
clear
delete
- delete(key): boolean
Parameters
- key: ResourceIdentifier
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.
-
entries
- entries(): IterableIterator<[ResourceIdentifier, T]>
Returns an iterable of key, value pairs for every entry in the map.
-Returns IterableIterator<[ResourceIdentifier, T]>
for
- for
Each(callbackfn, thisArg?): void Executes a provided function once per each key/value pair in the Map, in insertion order.
-Parameters
- callbackfn: ((value: T, key: ResourceIdentifier, map: Map<ResourceIdentifier, T>) => void)
- (value, key, map): void
Parameters
- value: T
- key: ResourceIdentifier
- map: Map<ResourceIdentifier, T>
Returns void
OptionalthisArg: unknown
Returns void
- callbackfn: ((value: T, key: ResourceIdentifier, map: Map<ResourceIdentifier, T>) => void)
get
- get(key): undefined | T
Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
-Parameters
- key: ResourceIdentifier
Returns undefined | T
Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
-
has
- has(key): boolean
Parameters
- key: ResourceIdentifier
Returns boolean
boolean indicating whether an element with the specified key exists or not.
-
keys
- keys(): IterableIterator<ResourceIdentifier>
Returns an iterable of keys in the map
-Returns IterableIterator<ResourceIdentifier>
set
- set(key, value): this
Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
-Parameters
- key: ResourceIdentifier
- value: T
Returns this
values
Class IdentifierSetMultiMap<T>
A specific implementation of WrappedSetMultiMap where the key type is ResourceIdentifier.
-Type Parameters
Hierarchy (view full)
- WrappedSetMultiMap<ResourceIdentifier, T>
- IdentifierSetMultiMap
Index
Constructors
constructor
- new
Identifier Set Multi Map<T>(iterable?): IdentifierSetMultiMap<T> Type Parameters
Parameters
Optionaliterable: Iterable<readonly [ResourceIdentifier, T | ReadonlySet<T>]>
Returns IdentifierSetMultiMap<T>
Methods
[iterator]
- [iterator](): IterableIterator<[ResourceIdentifier, T]>
Returns IterableIterator<[ResourceIdentifier, T]>
add
- add(key, value): this
Adds the given key/value binding to the Map.
-Parameters
- key: ResourceIdentifier
- value: T | ReadonlySet<T>
Returns this
as
- as
Map(): ReadonlyMap<ResourceIdentifier, ReadonlySet<T>> Returns a Readonly Map representation of this Map.
-Returns ReadonlyMap<ResourceIdentifier, ReadonlySet<T>>
clear
delete
- delete(key): boolean
Parameters
- key: ResourceIdentifier
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.
-
delete
- delete
Entry(key, value): boolean Deletes the given key/value binding from the Map.
-Parameters
- key: ResourceIdentifier
- value: T
Returns boolean
distinct
- distinct
Keys(): IterableIterator<ResourceIdentifier> Iterates over all distinct keys in this Map.
-Returns IterableIterator<ResourceIdentifier>
entries
- entries(): IterableIterator<[ResourceIdentifier, T]>
Iterates over all key/value bindings in this Map.
-Returns IterableIterator<[ResourceIdentifier, T]>
entry
- entry
Sets(): IterableIterator<[ResourceIdentifier, ReadonlySet<T>]> Iterates over all distinct keys in this Map, together with a Set of their values.
-Returns IterableIterator<[ResourceIdentifier, ReadonlySet<T>]>
for
- for
Each(callbackfn, thisArg?): void Loops over all key/value bindings.
-Parameters
- callbackfn: ((value: T, key: ResourceIdentifier, map: SetMultiMap<ResourceIdentifier, T>) => void)
- (value, key, map): void
Parameters
- value: T
- key: ResourceIdentifier
- map: SetMultiMap<ResourceIdentifier, T>
Returns void
OptionalthisArg: unknown
Returns void
- callbackfn: ((value: T, key: ResourceIdentifier, map: SetMultiMap<ResourceIdentifier, T>) => void)
get
- get(key): undefined | ReadonlySet<T>
Returns all values stored for the given key. -Returns
-undefinedif there are no values for this key.Parameters
- key: ResourceIdentifier
Returns undefined | ReadonlySet<T>
has
- has(key): boolean
Parameters
- key: ResourceIdentifier
Returns boolean
boolean indicating whether an element with the specified key exists or not.
-
has
- has
Entry(key, value): boolean Returns true if this key/value binding exists in the Map.
-Parameters
- key: ResourceIdentifier
- value: T
Returns boolean
keys
- keys(): IterableIterator<ResourceIdentifier>
Returns an iterable of keys in the map
-Returns IterableIterator<ResourceIdentifier>
set
- set(key, value): this
Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
-Parameters
- key: ResourceIdentifier
- value: T | ReadonlySet<T>
Returns this
value
values
Class IdentityProviderFactory
Creates an OIDC Provider based on the provided configuration and parameters.
-The provider will be cached and returned on subsequent calls.
-Cookie and JWT keys will be stored in an internal storage, so they can be re-used over multiple threads.
-Necessary claims for Solid OIDC interactions will be added.
-Routes will be updated based on the baseUrl and oidcPath.
Implements
Index
Constructors
constructor
- new
Identity Provider Factory(config, args): IdentityProviderFactory Parameters
- config: Configuration
JSON config for the OIDC library
- - args: IdentityProviderFactoryArgs
Remaining parameters required for the factory.
-
Returns IdentityProviderFactory
- config: Configuration
Class IdentityProviderHttpHandler
Generates the active Interaction object if there is an ongoing OIDC interaction. -Finds the account ID if there is cookie metadata.
-Calls the stored InteractionHandler with that information and returns the result.
-Hierarchy (view full)
- OperationHttpHandler
- IdentityProviderHttpHandler
Index
Constructors
constructor
- new
Identity Provider Http Handler(args): IdentityProviderHttpHandler Parameters
Returns IdentityProviderHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class ImmutableMetadataPatcher
Guarantees that certain PATCH operations MUST NOT update certain triples in metadata resources. -Furthermore, this class also handles the patching for metadata resources. -List of triples that must not be updated are given during instantiation with the ImmutableTriple class. -When there is a change to an Immutable Triple, then a ConflictError will be thrown.
-Hierarchy (view full)
- RepresentationPatcher<RdfDatasetRepresentation>
- ImmutableMetadataPatcher
Index
Constructors
constructor
- new
Immutable Metadata Patcher(patcher, metadataStrategy, immutablePatterns): ImmutableMetadataPatcher Parameters
- patcher: RepresentationPatcher<RdfDatasetRepresentation>
- metadataStrategy: AuxiliaryStrategy
- immutablePatterns: FilterPattern[]
Returns ImmutableMetadataPatcher
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle(input): Promise<RdfDatasetRepresentation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that needs to be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle
Safe(input): Promise<RdfDatasetRepresentation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input data that will be handled if it can be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Class InMemoryDataAccessor
A DataAccessor is the building block closest to the actual data storage. -It should not worry about most Solid logic, most of that will be handled before it is called. -There are a few things it still needs to do, and it is very important every implementation does this:
--
-
- If the input identifier ends with a slash, it should be assumed the identifier is targeting a container. -
- Similarly, if there is no trailing slash it should assume a document. -
- It should always throw a NotFoundHttpError if it does not have data matching the input identifier. -
- DataAccessors should not generate containment triples. This will be done externally using
getChildren.
-
Implements
Index
Constructors
Methods
Constructors
constructor
- new
In Memory Data Accessor(identifierStrategy): InMemoryDataAccessor Parameters
- identifierStrategy: IdentifierStrategy
Returns InMemoryDataAccessor
Methods
can
delete
- delete
Resource(identifier): Promise<void> Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata corresponding to the identifier. -If possible, it is suggested to add a
-posix:sizetriple to the metadata indicating the binary size. -This is necessary for range requests.Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
- write
Container(identifier, metadata): Promise<void> Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Document(identifier, data, metadata): Promise<void> Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class IndexRepresentationStore
Allow containers to have a custom representation. -The index representation will be returned when the following conditions are fulfilled:
--
-
- The request targets a container. -
- A resource with the given
indexNameexists in the container. (default: "index.html")
- - The highest weighted preference matches the
mediaRange(default: "text/html") -Otherwise the request will be passed on to the source store. -In case the index representation should always be returned when it exists, -themediaRangeshould be set to "*∕*".
-
Note: this functionality is not yet part of the specification. Relevant issues are:
- -Hierarchy (view full)
- PassthroughStore
- IndexRepresentationStore
Index
Constructors
constructor
- new
Index Representation Store(source, indexName?, mediaRange?): IndexRepresentationStore Parameters
- source: ResourceStore
- indexName: string = 'index.html'
- mediaRange: string = 'text/html'
Returns IndexRepresentationStore
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class InitializableHandler
Allows using an Initializable as an Initializer Handler.
-Hierarchy (view full)
- Initializer
- InitializableHandler
Index
Constructors
constructor
- new
Initializable Handler(initializable): InitializableHandler Parameters
- initializable: Initializable
Returns InitializableHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class InitializerAbstract
Initializer is used to indicate an AsyncHandler that performs initialization logic.
-Hierarchy (view full)
- AsyncHandler
- Initializer
Index
Constructors
Methods
Constructors
constructor
- new
Initializer(): Initializer Returns Initializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: void
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: void
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class InteractionHandlerAbstract
Handler used for IDP interactions.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Interaction Handler(): InteractionHandler Returns InteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: InteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: InteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: InteractionHandlerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: InteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
Class InteractionRouteHandler<T>
InteractionHandler that only accepts input of which the target matches the stored route.
-Rejects operations that target a different route, -otherwise the input parameters are passed to the source handler.
-Type Parameters
- T extends InteractionRoute<string>
Hierarchy (view full)
- JsonInteractionHandler
- InteractionRouteHandler
Index
Constructors
constructor
- new
Interaction Route Handler<T>(route, source): InteractionRouteHandler<T> Type Parameters
- T extends InteractionRoute<string>
Parameters
- route: T
- source: JsonInteractionHandler<Dict<Json>>
Returns InteractionRouteHandler<T>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class IntermediateCreateExtractor
Returns the required access modes from the source ModesExtractor. -In case create permissions are required, -verifies if any of the containers permissions also need to be created -and adds the corresponding identifier/mode combinations.
-Hierarchy (view full)
- ModesExtractor
- IntermediateCreateExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Intermediate Create Extractor(resourceSet, strategy, source): IntermediateCreateExtractor Certain permissions depend on the existence of the target resource. -The provided ResourceSet will be used for that.
-Parameters
- resourceSet: ResourceSet
ResourceSet that can verify the target resource existence.
- - strategy: IdentifierStrategy
IdentifierStrategy that will be used to determine parent containers.
- - source: ModesExtractor
The source ModesExtractor.
-
Returns IntermediateCreateExtractor
- resourceSet: ResourceSet
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Operation
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
handle
- handle(input): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Operation
Input that needs to be handled.
-
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-- input: Operation
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class InternalServerError
A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
-Hierarchy
- BaseHttpError
- InternalServerError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Internal Server Error(message?, options?): InternalServerError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns InternalServerError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class JsonConversionHandler
An InteractionHandler that sits in-between -an InteractionHandler and a JsonInteractionHandler. -It converts the input data stream into a JSON object to be used by the stored handler.
-Since the JSON body is only made during the handle call, it can not be used during the canHandle,
-so the canHandle call of the stored handler is not called,
-meaning this class accepts all input that can be converted to JSON.
Hierarchy (view full)
- InteractionHandler
- JsonConversionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Json Conversion Handler(source, converter): JsonConversionHandler Parameters
- source: JsonInteractionHandler<Dict<Json>>
- converter: RepresentationConverter
Returns JsonConversionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: InteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: InteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: InteractionHandlerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: InteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
Class JsonFileStorage
Uses a JSON file to store key/value pairs.
-Implements
- KeyValueStorage<string, unknown>
Constructors
constructor
- new
Json File Storage(filePath, locker): JsonFileStorage Parameters
- filePath: string
- locker: ReadWriteLocker
Returns JsonFileStorage
Methods
delete
entries
get
has
set
- set(key, value): Promise<JsonFileStorage>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: unknown
Value to store.
-
Returns Promise<JsonFileStorage>
The storage.
-- key: string
Class JsonInteractionHandler<TOut>Abstract
A handler that consumes and returns a JSON object, -designed to be used for IDP/OIDC interactions.
-Type Parameters
Hierarchy (view full)
- AsyncHandler<JsonInteractionHandlerInput, JsonRepresentation<TOut>>
- JsonInteractionHandler
- ClientCredentialsDetailsHandler
- CreateClientCredentialsHandler
- DeleteClientCredentialsHandler
- LogoutHandler
- ResolveLoginHandler
- CancelOidcHandler
- ClientInfoHandler
- ConsentHandler
- ForgetWebIdHandler
- PromptHandler
- PickWebIdHandler
- CreatePasswordHandler
- DeletePasswordHandler
- ForgotPasswordHandler
- ResetPasswordHandler
- UpdatePasswordHandler
- CreatePodHandler
- UpdateOwnerHandler
- InteractionRouteHandler
- LinkWebIdHandler
- UnlinkWebIdHandler
- ControlHandler
- CookieInteractionHandler
- LocationInteractionHandler
- StaticInteractionHandler
- VersionHandler
- ViewInteractionHandler
- JsonInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Json Interaction Handler<TOut>(): JsonInteractionHandler<TOut> Type Parameters
Returns JsonInteractionHandler<TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Abstracthandle
- handle(input): Promise<JsonRepresentation<TOut>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<TOut>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<TOut>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<TOut>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class JsonLdNotificationSerializer
Serializes a Notification into a JSON-LD string.
-Hierarchy (view full)
- NotificationSerializer
- JsonLdNotificationSerializer
Index
Constructors
Methods
Constructors
constructor
- new
Json Ld Notification Serializer(): JsonLdNotificationSerializer Returns JsonLdNotificationSerializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationSerializerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationSerializerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: NotificationSerializerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationSerializerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
Class JsonResourceStorage<T>
A KeyValueStorage for JSON-like objects using a ResourceStore as backend.
-Creates a base URL by joining the input base URL with the container string. -The storage assumes it has ownership over all entries in the target container -so no other classes should access resources there to prevent issues.
-Assumes the input keys can be safely used to generate identifiers, -which will be appended to the stored base URL.
-All non-404 errors will be re-thrown.
-Type Parameters
Hierarchy (view full)
- JsonResourceStorage
Implements
- KeyValueStorage<string, T>
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Json Resource Storage<T>(source, baseUrl, container): JsonResourceStorage<T> Type Parameters
Parameters
- source: ResourceStore
- baseUrl: string
- container: string
Returns JsonResourceStorage<T>
Properties
Protected Readonlycontainer
Protected Readonlylogger
Protected Readonlysource
Methods
delete
entries
get
Protectedget
- get
Resource Entries(identifier): AsyncIterableIterator<[string, T]> Recursively iterates through the container to find all documents.
-Parameters
- identifier: ResourceIdentifier
Returns AsyncIterableIterator<[string, T]>
has
Protectedidentifier
- identifier
To Key(identifier): string Converts an internal identifier to an external key.
-Parameters
- identifier: ResourceIdentifier
Returns string
Protectedkey
- key
To Identifier(key): ResourceIdentifier Converts a key into an identifier for internal storage.
-Parameters
- key: string
Returns ResourceIdentifier
Protectedsafely
- safely
Get Resource(identifier): Promise<undefined | Representation> Returns the representation for the given identifier. -Returns undefined if a 404 error is thrown. -Re-throws the error in all other cases.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<undefined | Representation>
set
- set(key, value): Promise<JsonResourceStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: unknown
Value to store.
-
Returns Promise<JsonResourceStorage<T>>
The storage.
-- key: string
Class KeyExtractor
A simple ShorthandExtractor that extracts a single value from the input map. -Returns the default value if it was defined in case no value was found in the map.
-Hierarchy (view full)
- ShorthandExtractor
- KeyExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Key Extractor(key, defaultValue?): KeyExtractor Parameters
- key: string
OptionaldefaultValue: unknown
Returns KeyExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
handle
- handle(args): Promise<unknown>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- args: Shorthand
Returns Promise<unknown>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<unknown> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<unknown>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class KeyValueChannelStorage
Stores all the NotificationChannel in a KeyValueStorage. -Encodes IDs/topics before storing them in the KeyValueStorage.
-Uses a ReadWriteLocker to prevent internal race conditions.
-Implements
Constructors
constructor
- new
Key Value Channel Storage(storage, locker): KeyValueChannelStorage Parameters
- storage: KeyValueStorage<string, StorageValue>
- locker: ReadWriteLocker
Returns KeyValueChannelStorage
Methods
add
- add(channel): Promise<void>
Adds the given channel to the storage.
-Parameters
- channel: NotificationChannel
Channel to add.
-
Returns Promise<void>
- channel: NotificationChannel
delete
get
- get(id): Promise<undefined | NotificationChannel>
Returns the requested channel. -
-undefinedif no match was found or if the notification channel expired.Parameters
- id: string
The identifier of the notification channel.
-
Returns Promise<undefined | NotificationChannel>
- id: string
get
- get
All(topic): Promise<string[]> Returns the identifiers of all notification channel entries that have the given identifier as their topic. -The identifiers can potentially correspond to expired channels.
-Parameters
- topic: ResourceIdentifier
The identifier that is the topic.
-
Returns Promise<string[]>
- topic: ResourceIdentifier
update
- update(channel): Promise<void>
Updates the given notification channel. -The
-idand thetopiccan not be updated.Parameters
- channel: NotificationChannel
The channel to update.
-
Returns Promise<void>
- channel: NotificationChannel
Class LazyLoggerFactory
Wraps around another LoggerFactory that can be set lazily. -This is useful when objects are instantiated (and when they create loggers) -before the logging system has been fully instantiated, -as is the case when using a dependency injection framework such as Components.js.
-Loggers can be created even before a LoggerFactory is set; -any log messages will be buffered and re-emitted.
-Implements
Index
Constructors
constructor
- new
Lazy Logger Factory(options?): LazyLoggerFactory Parameters
- options: {
bufferSize?: number;
} = {}OptionalbufferSize?: number
Returns LazyLoggerFactory
- options: {
Accessors
logger
- get loggerFactory(): LoggerFactory
Returns LoggerFactory
- set loggerFactory(loggerFactory): void
Parameters
- loggerFactory: LoggerFactory
Returns void
Class LinkMetadataGenerator
Adds a link to the auxiliary resource when called on the subject resource.
-Specifically:
In case the input is metadata of an auxiliary resource no metadata will be added
-Hierarchy (view full)
- MetadataGenerator
- LinkMetadataGenerator
Index
Constructors
Methods
Constructors
constructor
- new
Link Metadata Generator(link, identifierStrategy): LinkMetadataGenerator Parameters
- link: string
- identifierStrategy: AuxiliaryIdentifierStrategy
Returns LinkMetadataGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationMetadata
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationMetadata
handle
- handle(metadata): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- metadata: RepresentationMetadata
Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationMetadata
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationMetadata
Class LinkRelMetadataWriter
A MetadataWriter that takes a linking metadata predicates to Link header "rel" values. -The values of the objects will be put in a Link header with the corresponding "rel" value.
-Hierarchy (view full)
- MetadataWriter
- LinkRelMetadataWriter
Index
Constructors
constructor
- new
Link Rel Metadata Writer(linkRelMap): LinkRelMetadataWriter Parameters
- linkRelMap: Record<string, string>
Returns LinkRelMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class LinkRelObject
Represents the values that are parsed as metadata
- Index
Constructors
constructor
- new
Link Rel Object(value, ephemeral?, allowList?): LinkRelObject Parameters
- value: string
The value corresponding to the
-relvalue that will be used as predicate in the metadata. Optionalephemeral: boolean(Optional) Indicates whether it will be stored by the server.
-OptionalallowList: string[](Optional) Contains the objects that are allowed to be used with the given predicate.
-
Returns LinkRelObject
- value: string
Properties
Readonlyallow
Readonlyephemeral
Readonlyvalue
Methods
add
- add
To Metadata(object, metadata, logger): void Adds the object to the metadata when it is allowed
-Parameters
- object: string
The link target.
- - metadata: RepresentationMetadata
Metadata of the resource.
- - logger: Logger
Logger
-
Returns void
- object: string
Class LinkRelParser
Parses Link headers with a specific rel value and adds them as metadata with the given predicate.
Hierarchy (view full)
- MetadataParser
- LinkRelParser
Index
Constructors
constructor
- new
Link Rel Parser(linkRelMap): LinkRelParser Parameters
- linkRelMap: Record<string, LinkRelObject>
Returns LinkRelParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class LinkWebIdHandler
Handles the linking of WebIDs to account, -thereby registering them to the server IDP.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- LinkWebIdHandler
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Link Web Id Handler(args): LinkWebIdHandler Parameters
- args: LinkWebIdHandlerArgs
Returns LinkWebIdHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ListeningActivityHandler
Listens to an ActivityEmitter and calls the stored NotificationHandlers in case of an event -for every matching notification channel found.
-Takes the rate feature into account so only channels that want a new notification will receive one.
Extends StaticHandler so it can be more easily injected into a Components.js configuration. -No class takes this one as input, so to make sure Components.js instantiates it, -it needs to be added somewhere where its presence has no impact, such as the list of initializers.
-Hierarchy (view full)
- StaticHandler
- ListeningActivityHandler
Index
Constructors
constructor
- new
Listening Activity Handler(storage, emitter, handler): ListeningActivityHandler Parameters
- storage: NotificationChannelStorage
- emitter: ActivityEmitter
- handler: NotificationHandler
Returns ListeningActivityHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: unknown
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: unknown
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
Class LocationInteractionHandler
Transforms an HTTP redirect into a hypermedia document with a redirection link, -such that scripts running in a browser can redirect the user to the next page.
-This handler addresses the situation where:
--
-
- the user visits a first page -
- this first page contains a script that performs interactions with a JSON API -
- as a result of a certain interaction, the user needs to be redirected to a second page -
Regular HTTP redirects are performed via responses with 3xx status codes. -However, since the consumer of the API in this case is a browser script, -a 3xx response would only reach that script and not move the page for the user.
-Therefore, this handler changes a 3xx response into a 200 response -with an explicit link to the next page, -enabling the script to move the user to the next page.
-Hierarchy (view full)
- JsonInteractionHandler
- LocationInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Location Interaction Handler(source): LocationInteractionHandler Parameters
- source: JsonInteractionHandler<Dict<Json>>
Returns LocationInteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class LockingInteractionHandler
An InteractionHandler that locks the path generated with the stored route during an operation. -If the route is the base account route, this can be used to prevent multiple operations on the same account.
-Hierarchy (view full)
- InteractionHandler
- LockingInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Locking Interaction Handler(locker, accountRoute, source): LockingInteractionHandler Parameters
- locker: ReadWriteLocker
- accountRoute: AccountIdRoute
- source: InteractionHandler
Returns LockingInteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: InteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: InteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: InteractionHandlerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: InteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: InteractionHandlerInput
Class LockingResourceStore
Store that for every call acquires a lock before executing it on the requested resource, -and releases it afterwards. -In case the request returns a Representation the lock will only be released when the data stream is finished.
-For auxiliary resources the lock will be applied to the subject resource. -The actual operation is still executed on the auxiliary resource.
-Implements
Index
Constructors
constructor
- new
Locking Resource Store(source, locks, auxiliaryStrategy): LockingResourceStore Parameters
- source: ResourceStore
- locks: ExpiringReadWriteLocker
- auxiliaryStrategy: AuxiliaryIdentifierStrategy
Returns LockingResourceStore
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
Protectedcreate
- create
Expiring Representation(representation, maintainLock): Representation Wraps a representation to make it reset the timeout timer every time data is read.
-Parameters
- representation: Representation
The representation to wrap
- - maintainLock: (() => void)
Function to call to reset the timer.
-- (): void
Returns void
Returns Representation
- representation: Representation
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Protectedget
- get
Lock Identifier(identifier): ResourceIdentifier Acquires the correct identifier to lock this resource. -For auxiliary resources this means the subject identifier.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
Protectedlocked
- locked
Representation Run(identifier, whileLocked): Promise<Representation> Acquires a lock that is only released when all data of the resulting representation data has been read, -an error occurs, or the timeout has been triggered. -The resulting data stream will be adapted to reset the timer every time data is read.
-In case the data of the resulting stream is not needed it should be closed to prevent a timeout error.
-Parameters
- identifier: ResourceIdentifier
Identifier that should be locked.
- - whileLocked: (() => Promise<Representation>)
Function to be executed while the resource is locked.
-- (): Promise<Representation>
Returns Promise<Representation>
Returns Promise<Representation>
- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Protectedwait
Class LoggerInitializer
Sets up the global logger factory.
-Hierarchy (view full)
- Initializer
- LoggerInitializer
Index
Constructors
Methods
Constructors
constructor
- new
Logger Initializer(loggerFactory): LoggerInitializer Parameters
- loggerFactory: LoggerFactory
Returns LoggerInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class LogoutHandler
Responsible for logging a user out. -In practice this means making sure the cookie is no longer valid.
-Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- LogoutHandler
Index
Constructors
Methods
Constructors
constructor
- new
Logout Handler(cookieStore): LogoutHandler Parameters
- cookieStore: CookieStore
Returns LogoutHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class MappedMetadataWriter
A MetadataWriter that takes a map directly converting metadata predicates to headers. -The header value(s) will be the same as the corresponding object value(s).
-Hierarchy (view full)
- MetadataWriter
- MappedMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Mapped Metadata Writer(headerMap): MappedMetadataWriter Parameters
- headerMap: Record<string, string>
Returns MappedMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class MarkdownToHtmlConverter
Converts Markdown data to HTML.
-The generated HTML will be injected into the given template using the parameter htmlBody.
-A standard Markdown string will be converted to a
tag, so html and body tags should be part of the template.
-In case the Markdown body starts with a header (#), that value will also be used as title parameter.
Hierarchy (view full)
- BaseTypedRepresentationConverter
- MarkdownToHtmlConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Markdown To Html Converter(templateEngine): MarkdownToHtmlConverter Parameters
- templateEngine: TemplateEngine<Dict<unknown>>
Returns MarkdownToHtmlConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class MaxKeyLengthStorage<T>
A KeyValueStorage that hashes keys in case they would be longer than the set limit.
-Hashed keys are prefixed with a certain value to prevent issues with incoming keys that are already hashed.
-The default max length is 150 and the default prefix is $hash$.
This class mostly exists to prevent issues when writing storage entries to disk.
-Keys that are too long would cause issues with the file name limit.
-For this reason, only the part after the last / in a key is hashed, to preserve the expected file structure.
Type Parameters
Implements
- KeyValueStorage<string, T>
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Max Key Length Storage<T>(source, maxKeyLength?, hashPrefix?): MaxKeyLengthStorage<T> Type Parameters
Parameters
- source: KeyValueStorage<string, Entry<T>>
- maxKeyLength: number = 150
- hashPrefix: string = '$hash$'
Returns MaxKeyLengthStorage<T>
Properties
Protected Readonlyhash
Protected Readonlylogger
Protected Readonlymax
Protected Readonlysource
Methods
delete
entries
get
Protectedget
Protectedget
has
set
- set(key, value): Promise<MaxKeyLengthStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: T
Value to store.
-
Returns Promise<MaxKeyLengthStorage<T>>
The storage.
-- key: string
Protectedwrap
Class MemoryMapStorage<TValue>
A KeyValueStorage which uses a JavaScript Map for internal storage.
-Type Parameters
Implements
- KeyValueStorage<string, TValue>
Constructors
constructor
- new
Memory Map Storage<TValue>(): MemoryMapStorage<TValue> Type Parameters
Returns MemoryMapStorage<TValue>
Methods
delete
entries
get
has
set
- set(key, value): Promise<MemoryMapStorage<TValue>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: TValue
Value to store.
-
Returns Promise<MemoryMapStorage<TValue>>
The storage.
-- key: string
Class MemoryResourceLocker
A resource locker making use of the async-lock library.
-Note that all locks are kept in memory until they are unlocked which could potentially result
-in a memory leak if locks are never unlocked, so make sure this is covered with expiring locks for example,
-and/or proper finally handles.
Implements
Index
Constructors
constructor
- new
Memory Resource Locker(): MemoryResourceLocker Returns MemoryResourceLocker
Methods
acquire
- acquire(identifier): Promise<void>
Acquires a lock on the requested identifier. -The promise will resolve when the lock has been acquired.
-Parameters
- identifier: ResourceIdentifier
Resource to acquire a lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
release
- release(identifier): Promise<void>
Releases a lock on the requested identifier. -The promise will resolve when the lock has been released. -If there is no lock on the resource, an error should be thrown.
-Parameters
- identifier: ResourceIdentifier
Resource to release the lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class MetadataGeneratorAbstract
Generic interface for classes that add metadata to a RepresentationMetadata.
-Hierarchy (view full)
- AsyncHandler<RepresentationMetadata>
- MetadataGenerator
Index
Constructors
Methods
Constructors
constructor
- new
Metadata Generator(): MetadataGenerator Returns MetadataGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationMetadata
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationMetadata
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationMetadata
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: RepresentationMetadata
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationMetadata
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationMetadata
Class MetadataParserAbstract
A parser that takes a specific part of an HttpRequest and converts it into metadata, -such as the value of a header entry.
-Hierarchy (view full)
- AsyncHandler<{
metadata: RepresentationMetadata;
request: HttpRequest;
}>
Index
Constructors
Methods
Constructors
constructor
- new
Metadata Parser(): MetadataParser Returns MetadataParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class MetadataWriterAbstract
A serializer that converts metadata to headers for an HttpResponse.
-Hierarchy (view full)
- AsyncHandler<MetadataWriterInput>
- MetadataWriter
- AllowAcceptHeaderWriter
- AuxiliaryLinkMetadataWriter
- ConstantMetadataWriter
- ContentTypeMetadataWriter
- CookieMetadataWriter
- LinkRelMetadataWriter
- MappedMetadataWriter
- ModifiedMetadataWriter
- RangeMetadataWriter
- StorageDescriptionAdvertiser
- WacAllowMetadataWriter
- WwwAuthMetadataWriter
- OwnerMetadataWriter
- StreamingHttpMetadataWriter
- MetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Metadata Writer(): MetadataWriter Returns MetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: MetadataWriterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: MetadataWriterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class MethodFilterHandler<TIn, TOut>
Only accepts requests where the input has a (possibly nested) method field
-that matches any one of the given methods.
-In case of a match, the input will be sent to the source handler.
Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut>
- MethodFilterHandler
Index
Constructors
Methods
Constructors
constructor
- new
Method Filter Handler<TIn, TOut>(methods, source): MethodFilterHandler<TIn, TOut> Type Parameters
Parameters
- methods: string[]
- source: AsyncHandler<TIn, TOut>
Returns MethodFilterHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class MethodModesExtractor
Generates permissions for the base set of methods that always require the same permissions. -Specifically: GET, HEAD, POST, PUT and DELETE.
-Hierarchy (view full)
- ModesExtractor
- MethodModesExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Method Modes Extractor(resourceSet): MethodModesExtractor Certain permissions depend on the existence of the target resource. -The provided ResourceSet will be used for that.
-Parameters
- resourceSet: ResourceSet
ResourceSet that can verify the target resource existence.
-
Returns MethodModesExtractor
- resourceSet: ResourceSet
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Operation
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
handle
- handle(input): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Operation
Input that needs to be handled.
-
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-- input: Operation
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class MethodNotAllowedHttpError
An error thrown when data was found for the requested identifier, but is not supported by the target resource. -Can keep track of the methods that are not allowed.
-Hierarchy
- BaseHttpError
- MethodNotAllowedHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Method Not Allowed Http Error(methods?, message?, options?): MethodNotAllowedHttpError Parameters
- methods: string[] = []
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns MethodNotAllowedHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
Readonlymethods
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class ModesExtractorAbstract
Extracts all AccessModes that are necessary to execute the given Operation.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Modes Extractor(): ModesExtractor Returns ModesExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Operation
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Abstracthandle
- handle(input): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Operation
Input that needs to be handled.
-
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-- input: Operation
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class ModifiedMetadataWriter
A MetadataWriter that generates all the necessary headers related to the modification date of a resource.
-Hierarchy (view full)
- MetadataWriter
- ModifiedMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Modified Metadata Writer(): ModifiedMetadataWriter Returns ModifiedMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class ModuleVersionVerifier
This initializer simply writes the version number of the server to the storage. -This will be relevant in the future when we look into migration initializers.
-It automatically parses the version number from the package.json.
Hierarchy (view full)
- Initializer
- ModuleVersionVerifier
Index
Constructors
Methods
Constructors
constructor
- new
Module Version Verifier(storageKey, storage): ModuleVersionVerifier Parameters
- storageKey: string
- storage: KeyValueStorage<string, string>
Returns ModuleVersionVerifier
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class MonitoringStore<T>
Store that notifies listeners of changes to its source
-by emitting a changed event.
Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- BaseActivityEmitter
- MonitoringStore
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Monitoring Store<T>(source): MonitoringStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
Returns MonitoringStore<T>
Properties
add
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Alias for emitter.on(eventName, listener).
emit
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata]) => boolean) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", ...args: [target: ResourceIdentifier, metadata: RepresentationMetadata]) => boolean)
Synchronously calls each of the listeners registered for the event namedeventName, in the order they were registered, passing the supplied arguments
-to each.
Returns true if the event had listeners, false otherwise.
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
-event
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update")[])
Returns an array listing the events for which the emitter has registered
-listeners. The values in the array are strings or Symbols.
const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
-listener
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update") => number)
Returns the number of listeners listening to the event named eventName.
If listener is provided, it will return how many times the listener
-is found in the list of the listeners of the event.
listeners
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)[]) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update") => ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)[])
Returns a copy of the array of listeners for the event named eventName.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
-off
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Alias for emitter.removeListener().
on
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Adds the listener function to the end of the listeners array for the
-event named eventName. No checks are made to see if the listener has
-already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple
-times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. Theemitter.prependListener() method can be used as an alternative to add the
-event listener to the beginning of the listeners array.
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
-once
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Adds a one-timelistener function for the event named eventName. The
-next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. Theemitter.prependOnceListener() method can be used as an alternative to add the
-event listener to the beginning of the listeners array.
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
-prepend
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Adds the listener function to the beginning of the listeners array for the
-event named eventName. No checks are made to see if the listener has
-already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple
-times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
prepend
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
-listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
raw
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)[]) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update") => ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)[])
Returns a copy of the array of listeners for the event named eventName,
-including any wrappers (such as those created by .once()).
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
-remove
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update") => this)
Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
-particularly when the EventEmitter instance was created by some other
-component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
remove
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">, metadata: RepresentationMetadata) => void)) => this) & ((event:
| "https://www.w3.org/ns/activitystreams#object"
| "https://www.w3.org/ns/activitystreams#target"
| "https://www.w3.org/ns/activitystreams#Add"
| "https://www.w3.org/ns/activitystreams#Create"
| "https://www.w3.org/ns/activitystreams#Delete"
| "https://www.w3.org/ns/activitystreams#Remove"
| "https://www.w3.org/ns/activitystreams#Update", listener: ((target: ResourceIdentifier, metadata: RepresentationMetadata) => void)) => this)
Removes the specified listener from the listener array for the event namedeventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
-removeListener() will remove, at most, one instance of a listener from the
-listener array. If any single listener has been added multiple times to the
-listener array for the specified eventName, then removeListener() must be
-called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
-time of emitting are called in order. This implies that anyremoveListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
-will not remove them fromemit() in progress. Subsequent events behave as expected.
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
-Because listeners are managed using an internal array, calling this will
-change the position indices of any listener registered after the listener
-being removed. This will not impact the order in which listeners are called,
-but it means that any copies of the listener array as returned by
-the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
-event (as in the example below), removeListener() will remove the most
-recently added instance. In the example the once('ping')listener is removed:
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
-Returns a reference to the EventEmitter, so that calls can be chained.
Methods
Optional[capture
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Max Listeners(n): this By default
-EventEmitters will print a warning if more than10listeners are -added for a particular event. This is a useful default that helps finding -memory leaks. Theemitter.setMaxListeners()method allows the limit to be -modified for this specificEventEmitterinstance. The value can be set toInfinity(or0) to indicate an unlimited number of listeners.Returns a reference to the
-EventEmitter, so that calls can be chained.Parameters
- n: number
Returns this
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class MovedPermanentlyHttpError
Error used for resources that have been moved permanently. -Methods other than GET may or may not be changed to GET in subsequent requests.
-Hierarchy
- BaseHttpError
- MovedPermanentlyHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Moved Permanently Http Error(location, message?, options?): MovedPermanentlyHttpError Parameters
- location: string
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns MovedPermanentlyHttpError
Properties
Optional Readonlycause
Readonlyerror
Readonlylocation
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class N3PatchBodyParser
Parses an N3 Patch document and makes sure it conforms to the specification requirements. -Requirements can be found at Solid Protocol, §5.3.1: https://solid.github.io/specification/protocol#n3-patch
-Hierarchy (view full)
- BodyParser
- N3PatchBodyParser
Index
Constructors
Methods
Constructors
constructor
- new
N3 Patch Body Parser(): N3PatchBodyParser Returns N3PatchBodyParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: BodyParserArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
handle
- handle(input): Promise<N3Patch>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: BodyParserArgs
Input that needs to be handled.
-
Returns Promise<N3Patch>
A promise resolving when handling is finished.
-- input: BodyParserArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: BodyParserArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
Class N3PatchModesExtractor
Extracts the required access modes from an N3 Patch.
-Solid, §5.3.1: "When ?conditions is non-empty, servers MUST treat the request as a Read operation. -When ?insertions is non-empty, servers MUST (also) treat the request as an Append operation. -When ?deletions is non-empty, servers MUST treat the request as a Read and Write operation." -https://solid.github.io/specification/protocol#n3-patch
-Hierarchy (view full)
- ModesExtractor
- N3PatchModesExtractor
Index
Constructors
Methods
Constructors
constructor
- new
N3 Patch Modes Extractor(resourceSet): N3PatchModesExtractor Certain permissions depend on the existence of the target resource. -The provided ResourceSet will be used for that.
-Parameters
- resourceSet: ResourceSet
ResourceSet that can verify the target resource existence.
-
Returns N3PatchModesExtractor
- resourceSet: ResourceSet
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Operation
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
handle
- handle(input): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Operation
Input that needs to be handled.
-
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-- input: Operation
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class N3Patcher
Applies an N3 Patch to a representation, or creates a new one if required. -Follows all the steps from Solid, §5.3.1: https://solid.github.io/specification/protocol#n3-patch
-Hierarchy (view full)
- RepresentationPatcher<RdfDatasetRepresentation>
- N3Patcher
Index
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle(input): Promise<RdfDatasetRepresentation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that needs to be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle
Safe(input): Promise<RdfDatasetRepresentation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input data that will be handled if it can be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Class NoCheckOwnershipValidator
Does not do any checks to verify if the agent doing the request is actually the owner of the WebID. -This should only be used for debugging.
-Hierarchy (view full)
- OwnershipValidator
- NoCheckOwnershipValidator
Index
Constructors
constructor
- new
No Check Ownership Validator(): NoCheckOwnershipValidator Returns NoCheckOwnershipValidator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
webId: string;
}Input that could potentially be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
webId: string;
}Input that needs to be handled.
-web
Id: string
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
webId: string;
}Input data that will be handled if it can be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class NotFoundHttpError
An error thrown when no data was found for the requested identifier.
-Hierarchy
- BaseHttpError
- NotFoundHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Not Found Http Error(message?, options?): NotFoundHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns NotFoundHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class NotImplementedHttpError
The server either does not recognize the request method, or it lacks the ability to fulfil the request. -Usually this implies future availability (e.g., a new feature of a web-service API).
-Hierarchy
- BaseHttpError
- NotImplementedHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Not Implemented Http Error(message?, options?): NotImplementedHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns NotImplementedHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class NotificationDescriber
Outputs quads describing all the subscription services of the server, -as described in https://solidproject.org/TR/2022/notifications-protocol-20221231#discovery and -https://solidproject.org/TR/2022/notifications-protocol-20221231#description-resource-data-model.
-In the future, if there is ever a need to add notification channels to the description resource as described above, -this functionality should probably be added here as well.
-Hierarchy (view full)
- StorageDescriber
- NotificationDescriber
Index
Constructors
Methods
Constructors
constructor
- new
Notification Describer(converter, subscriptions): NotificationDescriber Parameters
- converter: RepresentationConverter
- subscriptions: NotificationChannelType[]
Returns NotificationDescriber
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ResourceIdentifier
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
handle
- handle(identifier): Promise<Quad[]>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<Quad[]>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Quad[]> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ResourceIdentifier
Input data that will be handled if it can be handled.
-
Returns Promise<Quad[]>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
Class NotificationEmitterAbstract
Emits a serialized Notification to the channel.
-Hierarchy (view full)
- AsyncHandler<NotificationEmitterInput>
- NotificationEmitter
Index
Constructors
Methods
Constructors
constructor
- new
Notification Emitter(): NotificationEmitter Returns NotificationEmitter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationEmitterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationEmitterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationEmitterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationEmitterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
Class NotificationGeneratorAbstract
Creates a Notification based on the provided input.
-Hierarchy (view full)
- AsyncHandler<NotificationHandlerInput, Notification>
Index
Constructors
Methods
Constructors
constructor
- new
Notification Generator(): NotificationGenerator Returns NotificationGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Abstracthandle
- handle(input): Promise<Notification>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<Notification>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<Notification> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Notification>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class NotificationHandlerAbstract
Makes sure an activity gets emitted to the relevant channel.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Notification Handler(): NotificationHandler Returns NotificationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class NotificationSerializerAbstract
Converts a Notification into a Representation that can be transmitted.
-This is a separate class between a generator and emitter, -so that a specific notification channel type can add extra metadata to the Representation if needed.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Notification Serializer(): NotificationSerializer Returns NotificationSerializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationSerializerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationSerializerInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: NotificationSerializerInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationSerializerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationSerializerInput
Class NotificationSubscriber
Handles notification subscriptions by creating a notification channel.
-Uses the information from the provided NotificationChannelType to validate the input -and verify the request has the required permissions available. -If successful the generated channel will be stored in a NotificationChannelStorage.
-Hierarchy (view full)
- OperationHttpHandler
- NotificationSubscriber
Index
Constructors
constructor
- new
Notification Subscriber(args): NotificationSubscriber Parameters
Returns NotificationSubscriber
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class NotificationUnsubscriber
Allows clients to unsubscribe from notification channels.
-Should be wrapped in a route handler that only allows DELETE operations.
Hierarchy (view full)
- OperationHttpHandler
- NotificationUnsubscriber
Index
Constructors
constructor
- new
Notification Unsubscriber(storage): NotificationUnsubscriber Parameters
- storage: NotificationChannelStorage
Returns NotificationUnsubscriber
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class OAuthHttpError
Represents on OAuth error that is being thrown. -OAuth error responses have additional fields that need to be present in the JSON response, -as described in RFC 6749, §4.1.2.1.
-Hierarchy (view full)
- HttpError
- OAuthHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new OAuth
Http Error(mandatoryFields, name?, statusCode?, message?, options?): OAuthHttpError Parameters
- mandatoryFields: OAuthErrorFields
Optionalname: stringOptionalstatusCode: numberOptionalmessage: stringOptionaloptions: HttpErrorOptions
Returns OAuthHttpError
Properties
Optional Readonlycause
Readonlyerror
Readonlymandatory
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Optionalprepare
Optional override for formatting stack traces
-Staticstack
Methods
Protectedgenerate
Staticcapture
Staticis
- is
Instance(error): error is OAuthHttpError Parameters
- error: unknown
Returns error is OAuthHttpError
Class OidcControlHandler
A ControlHandler that only returns results if there is an active OIDC interaction.
-Hierarchy (view full)
- ControlHandler
- OidcControlHandler
Index
Constructors
Methods
Constructors
constructor
- new
Oidc Control Handler(controls, source?): OidcControlHandler Parameters
- controls: Record<string, InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>>
Optionalsource: JsonInteractionHandler<Dict<Json>>
Returns OidcControlHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Protectedgenerate
- generate
Control Set(input, value): Promise<undefined | Json> Parameters
- input: JsonInteractionHandlerInput
- value: InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>
Returns Promise<undefined | Json>
Protectedgenerate
- generate
Controls(input): Promise<Dict<Json>> Generate the controls for all the stored keys.
-Parameters
- input: JsonInteractionHandlerInput
Returns Promise<Dict<Json>>
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Protectedis
- is
Route(value): value is InteractionRoute<never> Parameters
- value: InteractionRoute<never> | JsonInteractionHandler<Dict<Json>>
Returns value is InteractionRoute<never>
Protectedmerge
Class OidcHttpHandler
HTTP handler that redirects all requests to the OIDC library.
-Hierarchy (view full)
- HttpHandler
- OidcHttpHandler
Index
Constructors
constructor
- new
Oidc Http Handler(providerFactory): OidcHttpHandler Parameters
- providerFactory: ProviderFactory
Returns OidcHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class OkResponseDescription
Corresponds to a 200 or 206 response, containing relevant metadata and potentially data. -A 206 will be returned if range metadata is found in the metadata object.
-Hierarchy (view full)
- ResponseDescription
- OkResponseDescription
Index
Constructors
Properties
Constructors
constructor
- new
Ok Response Description(metadata, data?): OkResponseDescription Parameters
- metadata: RepresentationMetadata
Metadata concerning the response.
- Optionaldata: Guarded<Readable>Potential data.
-
Returns OkResponseDescription
- metadata: RepresentationMetadata
Class OperationHandlerAbstract
Handler for a specific operation type.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Operation Handler(): OperationHandler Returns OperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Abstracthandle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class OperationHttpHandlerAbstract
An HTTP handler that makes use of an already parsed Operation.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Operation Http Handler(): OperationHttpHandler Returns OperationHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Abstracthandle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class OperationRouterHandler
A BaseRouterHandler for an OperationHttpHandler.
-Hierarchy (view full)
- BaseRouterHandler<OperationHttpHandler>
- OperationRouterHandler
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Operation Router Handler(args): OperationRouterHandler Parameters
Returns OperationRouterHandler
Properties
Protected Readonlyall
Protected Readonlyallowed
Protected Readonlyallowed
Protected Readonlybase
Protected Readonlyhandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Protectedcan
- can
Handle Input(input, method, target): Promise<void> Parameters
- input: OperationHttpHandlerInput
- method: string
- target: ResourceIdentifier
Returns Promise<void>
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class OriginalUrlExtractor
Reconstructs the original URL of an incoming HttpRequest.
-Hierarchy (view full)
- TargetExtractor
- OriginalUrlExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Original Url Extractor(args): OriginalUrlExtractor Parameters
- args: OriginalUrlExtractorArgs
Returns OriginalUrlExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<ResourceIdentifier>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<ResourceIdentifier>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceIdentifier> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<ResourceIdentifier>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class OwnerMetadataWriter
Adds link headers indicating who the owners are when accessing the base URL of a pod. -Only owners that have decided to be visible will be shown.
-Solid, §4.1: "When a server wants to advertise the owner of a storage, -the server MUST include the Link header with rel="http://www.w3.org/ns/solid/terms#owner" -targeting the URI of the owner in the response of HTTP HEAD or GET requests targeting the root container." -https://solidproject.org/TR/2022/protocol-20221231#server-storage-link-owner
-Hierarchy (view full)
- MetadataWriter
- OwnerMetadataWriter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Owner Metadata Writer(podStore, storageStrategy): OwnerMetadataWriter Parameters
- podStore: PodStore
- storageStrategy: StorageLocationStrategy
Returns OwnerMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: MetadataWriterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: MetadataWriterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class OwnerPermissionReader
Allows control access if the request is being made by an owner of the pod containing the resource.
-Hierarchy (view full)
- PermissionReader
- OwnerPermissionReader
Index
Constructors
constructor
- new
Owner Permission Reader(podStore, authStrategy, storageStrategy): OwnerPermissionReader Parameters
- podStore: PodStore
- authStrategy: AuxiliaryIdentifierStrategy
- storageStrategy: StorageLocationStrategy
Returns OwnerPermissionReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Protectedfind
Protectedfind
- find
Pods(identifiers): Promise<Record<string, string>> Finds all pods that contain the given identifiers. -Return value is a record where the keys are the identifiers and the values the associated pod.
-Parameters
- identifiers: ResourceIdentifier[]
Returns Promise<Record<string, string>>
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class OwnershipValidatorAbstract
A class that validates if a someone owns a WebId. -Will throw an error if the WebId is not valid or ownership could not be validated. -The error message should contain a description of what is wrong and how it can be resolved.
-Hierarchy (view full)
- AsyncHandler<{
webId: string;
}>- OwnershipValidator
Index
Constructors
Methods
Constructors
constructor
- new
Ownership Validator(): OwnershipValidator Returns OwnershipValidator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
webId: string;
}Input that could potentially be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
webId: string;
}Input that needs to be handled.
-web
Id: string
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
webId: string;
}Input data that will be handled if it can be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class ParallelHandler<TIn, TOut>
A composite handler that executes handlers in parallel.
-Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut[]>
- ParallelHandler
Index
Constructors
Methods
Constructors
constructor
- new
Parallel Handler<TIn, TOut>(handlers): ParallelHandler<TIn, TOut> Type Parameters
Parameters
- handlers: AsyncHandler<TIn, TOut>[]
Returns ParallelHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<TOut[]>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut[]>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut[]> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut[]>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class ParentContainerReader
Determines delete and create permissions for those resources that need it
-by making sure the parent container has the required permissions.
Create requires append permissions on the parent container.
-Delete requires write permissions on both the parent container and the resource itself.
Hierarchy (view full)
- PermissionReader
- ParentContainerReader
Index
Constructors
constructor
- new
Parent Container Reader(reader, identifierStrategy): ParentContainerReader Parameters
- reader: PermissionReader
- identifierStrategy: IdentifierStrategy
Returns ParentContainerReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class ParsingHttpHandler
Parses requests and sends the resulting Operation to the wrapped OperationHttpHandler. -Errors are caught and handled by the ErrorHandler. -In case the OperationHttpHandler returns a result it will be sent to the ResponseWriter.
-Hierarchy (view full)
- HttpHandler
- ParsingHttpHandler
Index
Constructors
Methods
Constructors
constructor
- new
Parsing Http Handler(args): ParsingHttpHandler Parameters
- args: ParsingHttpHandlerArgs
Returns ParsingHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
Protectedhandle
- handle
Error(error, request): Promise<ResponseDescription> Handles the error output correctly based on the preferences.
-Parameters
- error: unknown
- request: HttpRequest
Returns Promise<ResponseDescription>
Protectedhandle
- handle
Request(request, response): Promise<ResponseDescription> Interprets the request and passes the generated Operation object to the stored OperationHttpHandler.
-Parameters
- request: HttpRequest
- response: HttpResponse
Returns Promise<ResponseDescription>
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class PartialReadWriteLocker
A BaseReadWriteLocker that stores the counter and its associated locks in memory. -The consequence of this is that multiple read requests are possible as long as they occur on the same worker thread. -A read request from a different worker thread will have to wait -until those from the current worker thread are finished.
-The main reason for this class is due to the file locker that we use only allowing locks to be released -by the same worker thread that acquired them.
-Hierarchy (view full)
- BaseReadWriteLocker
- PartialReadWriteLocker
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Partial Read Write Locker(locker): PartialReadWriteLocker Parameters
- locker: ResourceLocker
Returns PartialReadWriteLocker
Methods
Protectedget
- get
Count Lock Identifier(identifier): ResourceIdentifier Generate the identifier that will be used to acquire the count lock for the given identifier. -There will be cases where this lock needs to be acquired -while an active lock on the main resource is still being maintained. -This means that if the input
-resourceLockerandcountLockeruse the same locking system -this generated identifier needs to be different.Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
Protectedmodify
- modify
Count(identifier, mod): number Update the counter that keeps track of having open read locks there currently are.
-Parameters
- identifier: ResourceIdentifier
Identifier on which to update the number of read locks.
- - mod: number
-+1or-1.
Returns number
- identifier: ResourceIdentifier
Protectedwith
- with
Lock<T>(identifier, whileLocked): Promise<T> Acquires a new lock for the requested identifier. -Will resolve when the input function resolves.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
Function to resolve while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Class PassthroughAdapter
OIDC Adapter that calls the corresponding functions of the source Adapter. -Can be extended by adapters that do not want to override all functions -by implementing a decorator pattern.
-Hierarchy (view full)
- PassthroughAdapter
Implements
- Adapter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Passthrough Adapter(name, source): PassthroughAdapter Parameters
- name: string
- source: Adapter
Returns PassthroughAdapter
Class PassthroughAdapterFactory
A factory that generates an Adapter to be used by the IDP to persist information.
The oidc-provider library will call the relevant functions when it needs to find/create/delete metadata.
-For a full explanation of how these functions work and what is expected,
-have a look at https://github.com/panva/node-oidc-provider/blob/main/example/my_adapter.js
Hierarchy (view full)
- PassthroughAdapterFactory
Implements
Index
Constructors
constructor
- new
Passthrough Adapter Factory(source): PassthroughAdapterFactory Parameters
- source: AdapterFactory
Returns PassthroughAdapterFactory
Class PassthroughConverter
A RepresentationConverter that does not perform any conversion.
-Hierarchy (view full)
- RepresentationConverter
- PassthroughConverter
Index
Constructors
Methods
Constructors
constructor
- new
Passthrough Converter(): PassthroughConverter Returns PassthroughConverter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class PassthroughDataAccessor
DataAccessor that calls the corresponding functions of the source DataAccessor. -Can be extended by data accessors that do not want to override all functions -by implementing a decorator pattern.
-Hierarchy (view full)
- PassthroughDataAccessor
Implements
Index
Constructors
constructor
- new
Passthrough Data Accessor(accessor): PassthroughDataAccessor Parameters
- accessor: DataAccessor
Returns PassthroughDataAccessor
Methods
can
- can
Handle(representation): Promise<void> Should throw a NotImplementedHttpError if the DataAccessor does not support storing the given Representation.
-Parameters
- representation: Representation
Incoming Representation.
-
Returns Promise<void>
- representation: Representation
delete
- delete
Resource(identifier): Promise<void> Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata corresponding to the identifier. -If possible, it is suggested to add a
-posix:sizetriple to the metadata indicating the binary size. -This is necessary for range requests.Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
- write
Container(identifier, metadata): Promise<void> Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Document(identifier, data, metadata): Promise<void> Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class PassthroughKeyValueStorage<TVal>Abstract
Abstract class to create a KeyValueStorage by wrapping around another one.
-Exposes abstract functions to modify the key before passing it to the the source storage.
-Type Parameters
Hierarchy (view full)
- PassthroughKeyValueStorage
Implements
- KeyValueStorage<string, TVal>
Index
Constructors
Protectedconstructor
- new
Passthrough Key Value Storage<TVal>(source): PassthroughKeyValueStorage<TVal> Type Parameters
Parameters
- source: KeyValueStorage<string, TVal>
Returns PassthroughKeyValueStorage<TVal>
Methods
delete
entries
get
has
set
- set(key, value): Promise<PassthroughKeyValueStorage<TVal>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: TVal
Value to store.
-
Returns Promise<PassthroughKeyValueStorage<TVal>>
The storage.
-- key: string
Protected Abstractto
Protected Abstractto
Class PassthroughStore<T>
Store that calls the corresponding functions of the source Store. -Can be extended by stores that do not want to override all functions -by implementing a decorator pattern.
-Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
Implements
Index
Constructors
constructor
- new
Passthrough Store<T>(source): PassthroughStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
Returns PassthroughStore<T>
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class PasswordLoginHandler
Handles the submission of the Login Form and logs the user in.
-Hierarchy (view full)
- ResolveLoginHandler
- PasswordLoginHandler
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Password Login Handler(args): PasswordLoginHandler Parameters
- args: PasswordLoginHandlerArgs
Returns PasswordLoginHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(): Promise<JsonRepresentation<Dict<Json>>> Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
login
- login(input): Promise<JsonRepresentation<LoginOutputType>>
Takes the necessary steps to log a user in.
-Parameters
- input: JsonInteractionHandlerInput
Same input that was passed to the handle function.
-
Returns Promise<JsonRepresentation<LoginOutputType>>
- input: JsonInteractionHandlerInput
Protectedupdate
- update
Remember Setting(accountId, remember?): Promise<void> Updates the account setting that determines whether the login status needs to be remembered.
-Parameters
- accountId: string
ID of the account.
- Optionalremember: booleanIf the account should be remembered or not. The setting will not be updated if this is undefined.
-
Returns Promise<void>
- accountId: string
Class PatchHandler<T>Abstract
Executes the given Patch.
-Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- AsyncHandler<PatchHandlerInput<T>, ChangeMap>
- PatchHandler
Index
Constructors
Methods
Constructors
constructor
- new
Patch Handler<T>(): PatchHandler<T> Type Parameters
- T extends ResourceStore = ResourceStore
Returns PatchHandler<T>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PatchHandlerInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PatchHandlerInput<T>
Abstracthandle
- handle(input): Promise<ChangeMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PatchHandlerInput<T>
Input that needs to be handled.
-
Returns Promise<ChangeMap>
A promise resolving when handling is finished.
-- input: PatchHandlerInput<T>
handle
- handle
Safe(input): Promise<ChangeMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PatchHandlerInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<ChangeMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PatchHandlerInput<T>
Class PatchOperationHandler
Handles PATCH Operations. -Calls the modifyResource function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- PatchOperationHandler
Index
Constructors
constructor
- new
Patch Operation Handler(store): PatchOperationHandler Parameters
- store: ResourceStore
Returns PatchOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class PatchingStore<T>
ResourceStore using decorator pattern for the modifyResource function.
-If the original store supports the Patch, behaviour will be identical,
-otherwise the PatchHandler will be called instead.
Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- PassthroughStore<T>
- PatchingStore
Index
Constructors
constructor
- new
Patching Store<T>(source, patchHandler): PatchingStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
- patchHandler: PatchHandler<ResourceStore>
Returns PatchingStore<T>
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class PathBasedReader
Redirects requests to specific PermissionReaders based on their identifier. -The keys are regular expression strings. -The regular expressions should all start with a slash -and will be evaluated relative to the base URL.
-Will error if no match is found.
-Hierarchy (view full)
- PermissionReader
- PathBasedReader
Index
Constructors
constructor
- new
Path Based Reader(baseUrl, paths): PathBasedReader Parameters
- baseUrl: string
- paths: Record<string, PermissionReader>
Returns PathBasedReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class PermissionBasedAuthorizer
Authorizer that bases its decision on the output it gets from its PermissionReader.
-For each permission it checks if the reader allows that for at least one credential type,
-if yes, authorization is granted.
-undefined values for reader results are interpreted as false.
Hierarchy (view full)
- Authorizer
- PermissionBasedAuthorizer
Index
Constructors
constructor
- new
Permission Based Authorizer(resourceSet): PermissionBasedAuthorizer The existence of the target resource determines the output status code for certain situations. -The provided ResourceSet will be used for that.
-Parameters
- resourceSet: ResourceSet
ResourceSet that can verify the target resource existence.
-
Returns PermissionBasedAuthorizer
- resourceSet: ResourceSet
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AuthorizerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AuthorizerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AuthorizerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: AuthorizerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AuthorizerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AuthorizerInput
Class PermissionReaderAbstract
Discovers the permissions of the given credentials on the given identifier. -If the reader finds no permission for the requested identifiers and credentials, -it can return an empty or incomplete map.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Permission Reader(): PermissionReader Returns PermissionReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Abstracthandle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class PickWebIdHandler
Allows users to choose which WebID they want to authenticate as during an OIDC interaction.
-One of the main reason picking a WebID is a separate class/request from consenting to the OIDC interaction, -is because the OIDC-provider will only give the information we need for consent -once we have added an accountId to the OIDC interaction, which we do in this class. -The library also really wants to use that accountId as the value that you use for generating the tokens, -meaning we can't just use another value there, so we need to assign the WebID to it, -unless we use a hacky workaround.
-Hierarchy (view full)
- JsonInteractionHandler<never>
- PickWebIdHandler
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Pick Web Id Handler(webIdStore, providerFactory): PickWebIdHandler Parameters
- webIdStore: WebIdStore
- providerFactory: ProviderFactory
Returns PickWebIdHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<never>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<never>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<never>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<never>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class PlainJsonLdFilter
Filter that errors on JSON-LD with a plain application/json content-type. -This will not store metadata, only throw errors if necessary.
-Hierarchy (view full)
- MetadataParser
- PlainJsonLdFilter
Index
Constructors
constructor
- new
Plain Json Ld Filter(): PlainJsonLdFilter Returns PlainJsonLdFilter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class PodCreatorAbstract
Handles creating a pod and linking the created WebID.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Pod Creator(): PodCreator Returns PodCreator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PodCreatorInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PodCreatorInput
Abstracthandle
- handle(input): Promise<PodCreatorOutput>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PodCreatorInput
Input that needs to be handled.
-
Returns Promise<PodCreatorOutput>
A promise resolving when handling is finished.
-- input: PodCreatorInput
handle
- handle
Safe(input): Promise<PodCreatorOutput> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PodCreatorInput
Input data that will be handled if it can be handled.
-
Returns Promise<PodCreatorOutput>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PodCreatorInput
Class PodQuotaStrategy
The PodQuotaStrategy sets a limit on the amount of data stored on a per pod basis
-Hierarchy (view full)
- QuotaStrategy
- PodQuotaStrategy
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Pod Quota Strategy(limit, reporter, identifierStrategy, accessor): PodQuotaStrategy Parameters
- limit: Size
- reporter: SizeReporter<unknown>
- identifierStrategy: IdentifierStrategy
- accessor: DataAccessor
Returns PodQuotaStrategy
Methods
create
- create
Quota Guard(identifier): Promise<Guarded<PassThrough>> Get a Passthrough stream that will keep track of the available space. -If the quota is exceeded the stream will emit an error and destroy itself. -Like other Passthrough instances this will simply pass on the chunks, when the quota isn't exceeded.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource in question
-
Returns Promise<Guarded<PassThrough>>
a Passthrough instance that errors when quota is exceeded
-- identifier: ResourceIdentifier
estimate
- estimate
Size(metadata): Promise<undefined | Size> Get an estimated size of the resource
-Parameters
- metadata: RepresentationMetadata
the metadata that might include the size
-
Returns Promise<undefined | Size>
a Size object containing the estimated size and unit of the resource
-- metadata: RepresentationMetadata
get
- get
Available Space(identifier): Promise<Size> Get the available space when writing data to the given identifier. -If the given resource already exists it will deduct the already taken up -space by that resource since it is going to be overwritten and thus counts -as available space.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource of which you want the available space
-
Returns Promise<Size>
the available space and the unit of the space as a Size object
-- identifier: ResourceIdentifier
Protectedget
- get
Total Space Used(identifier): Promise<Size> Get the currently used/occupied space.
-Parameters
- identifier: ResourceIdentifier
the identifier that should be used to calculate the total
-
Returns Promise<Size>
a Size object containing the requested value. -If quota is not relevant for this identifier, Size.amount should be Number.MAX_SAFE_INTEGER
-- identifier: ResourceIdentifier
Class PodStorageLocationStrategy
A StorageLocationStrategy to be used when the server has pods which each are a different storage. -The IdentifierGenerator that is used to generate URLs for the pods -is used here to determine what the root pod URL is.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Pod Storage Location Strategy(generator): PodStorageLocationStrategy Parameters
- generator: IdentifierGenerator
Returns PodStorageLocationStrategy
Methods
get
- get
Storage Identifier(identifier): Promise<ResourceIdentifier> Returns the identifier of the storage that contains the given resource. -Can error if the input identifier is not part of any storage.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<ResourceIdentifier>
Class PostOperationHandler
Handles POST Operations. -Calls the addResource function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- PostOperationHandler
Index
Constructors
constructor
- new
Post Operation Handler(store): PostOperationHandler Parameters
- store: ResourceStore
Returns PostOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class PreconditionFailedHttpError
An error thrown when access was denied due to the conditions on the request.
-Hierarchy
- BaseHttpError
- PreconditionFailedHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Precondition Failed Http Error(message?, options?): PreconditionFailedHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns PreconditionFailedHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class PreferenceParserAbstract
Creates RepresentationPreferences based on the incoming HTTP headers in a HttpRequest.
-Hierarchy (view full)
- AsyncHandler<{
request: HttpRequest;
}, RepresentationPreferences>- PreferenceParser
Index
Constructors
Methods
Constructors
constructor
- new
Preference Parser(): PreferenceParser Returns PreferenceParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<RepresentationPreferences>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<RepresentationPreferences> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class PreferenceSupport
Helper class that checks if the stored RepresentationConverter and RepresentationPreferences -support the given input RepresentationPreferences and Representation.
-Creates a new object by combining the input arguments together with the stored preferences and checks -if the converter can handle that object.
- Index
Constructors
Methods
Constructors
constructor
- new
Preference Support(preferences, converter): PreferenceSupport Parameters
- preferences: RepresentationPreferences
- converter: RepresentationConverter
Returns PreferenceSupport
Methods
supports
- supports(input): Promise<boolean>
Parameters
- input: {
identifier: ResourceIdentifier;
representation: Representation;
}identifier: ResourceIdentifier
representation: Representation
Returns Promise<boolean>
- input: {
Class ProcessHandler<TIn, TOut>
A wrapper handler that will only run the wrapped handler if it is executed from:
--
-
- when running multithreaded: either the primary or a worker process -
- when running singlethreaded: the only process (i.e. always) -
Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut>
- ProcessHandler
Index
Constructors
Methods
Constructors
constructor
- new
Process Handler<TIn, TOut>(source, clusterManager, executeOnPrimary): ProcessHandler<TIn, TOut> Creates a new ProcessHandler
-Type Parameters
Parameters
- source: AsyncHandler<TIn, TOut>
The wrapped handler
- - clusterManager: ClusterManager
The ClusterManager in use
- - executeOnPrimary: boolean
Whether to execute the source handler when the process is the primary or a worker.
-
Returns ProcessHandler<TIn, TOut>
- source: AsyncHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class PromptFactoryAbstract
Used to generate custom interactionPolicy.Prompts.
-Hierarchy (view full)
- AsyncHandler<interactionPolicy.DefaultPolicy>
- PromptFactory
Index
Constructors
Methods
Constructors
constructor
- new
Prompt Factory(): PromptFactory Returns PromptFactory
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: DefaultPolicy
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: DefaultPolicy
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: DefaultPolicy
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: DefaultPolicy
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: DefaultPolicy
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: DefaultPolicy
Class PromptHandler
Redirects requests based on the OIDC Interaction prompt. -Errors in case no match was found.
-The reason we use this intermediate handler -instead of letting the OIDC library redirect directly to the correct page, -is because that library creates a cookie with of scope of the target page. -By having the library always redirect to the index page, -the cookie is relevant for all pages and other pages can see if we are still in an interaction.
-Hierarchy (view full)
- JsonInteractionHandler<OutType>
- PromptHandler
Index
Constructors
Methods
Constructors
constructor
- new
Prompt Handler(promptRoutes): PromptHandler Parameters
- promptRoutes: Record<string, InteractionRoute<never>>
Returns PromptHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<OutType>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<OutType>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<OutType>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class PublicCredentialsExtractor
Extracts the "public credentials", to be used for data everyone has access to. -This class mainly exists so a Credentials is still generated in case the token parsing fails.
-Hierarchy (view full)
- CredentialsExtractor
- PublicCredentialsExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Public Credentials Extractor(): PublicCredentialsExtractor Returns PublicCredentialsExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<Credentials>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class PutOperationHandler
Handles PUT Operations. -Calls the setRepresentation function from a ResourceStore.
-Hierarchy (view full)
- OperationHandler
- PutOperationHandler
Index
Constructors
constructor
- new
Put Operation Handler(store, metadataStrategy): PutOperationHandler Parameters
- store: ResourceStore
- metadataStrategy: AuxiliaryStrategy
Returns PutOperationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHandlerInput
Class QuadToRdfConverter
Converts internal/quads to most major RDF serializations.
Hierarchy (view full)
- BaseTypedRepresentationConverter
- QuadToRdfConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Quad To Rdf Converter(options?): QuadToRdfConverter Parameters
- options: {
outputPreferences?: Record<string, number>;
} = {}OptionaloutputPreferences?: Record<string, number>
Returns QuadToRdfConverter
- options: {
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class QuotaStrategyAbstract
A QuotaStrategy is used when we want to set a limit to the amount of data that can be -stored on the server. -This can range from a limit for the whole server to a limit on a per pod basis. -The way the size of a resource is calculated is implemented by the implementing classes. -This can be bytes, quads, file count, ...
-Hierarchy (view full)
- QuotaStrategy
Index
Constructors
Properties
Methods
Constructors
Protectedconstructor
- new
Quota Strategy(reporter, limit): QuotaStrategy Parameters
- reporter: SizeReporter<unknown>
- limit: Size
Returns QuotaStrategy
Methods
create
- create
Quota Guard(identifier): Promise<Guarded<PassThrough>> Get a Passthrough stream that will keep track of the available space. -If the quota is exceeded the stream will emit an error and destroy itself. -Like other Passthrough instances this will simply pass on the chunks, when the quota isn't exceeded.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource in question
-
Returns Promise<Guarded<PassThrough>>
a Passthrough instance that errors when quota is exceeded
-- identifier: ResourceIdentifier
estimate
- estimate
Size(metadata): Promise<undefined | Size> Get an estimated size of the resource
-Parameters
- metadata: RepresentationMetadata
the metadata that might include the size
-
Returns Promise<undefined | Size>
a Size object containing the estimated size and unit of the resource
-- metadata: RepresentationMetadata
get
- get
Available Space(identifier): Promise<Size> Get the available space when writing data to the given identifier. -If the given resource already exists it will deduct the already taken up -space by that resource since it is going to be overwritten and thus counts -as available space.
-Parameters
- identifier: ResourceIdentifier
the identifier of the resource of which you want the available space
-
Returns Promise<Size>
the available space and the unit of the space as a Size object
-- identifier: ResourceIdentifier
Protected Abstractget
- get
Total Space Used(identifier): Promise<Size> Get the currently used/occupied space.
-Parameters
- identifier: ResourceIdentifier
the identifier that should be used to calculate the total
-
Returns Promise<Size>
a Size object containing the requested value. -If quota is not relevant for this identifier, Size.amount should be Number.MAX_SAFE_INTEGER
-- identifier: ResourceIdentifier
Class QuotaValidator
The QuotaValidator validates data streams by making sure they would not exceed the limits of a QuotaStrategy.
-Hierarchy (view full)
- Validator
- QuotaValidator
Index
Constructors
Methods
Constructors
constructor
- new
Quota Validator(strategy): QuotaValidator Parameters
- strategy: QuotaStrategy
Returns QuotaValidator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ValidatorInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ValidatorInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: ValidatorInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ValidatorInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
Class RangeMetadataWriter
Generates the necessary content-range header if there is range metadata.
-If the start or end is unknown, a * will be used instead.
-According to the RFC, this is incorrect,
-but is all we can do as long as we don't know the full length of the representation in advance.
-For the same reason, the total length of the representation will always be *.
This class also adds the content-length header. -This will contain either the full size for standard requests, -or the size of the slice for range requests.
-Hierarchy (view full)
- MetadataWriter
- RangeMetadataWriter
Index
Constructors
constructor
- new
Range Metadata Writer(): RangeMetadataWriter Returns RangeMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class RangeNotSatisfiedHttpError
An error thrown when the requested range is not supported.
-Hierarchy
- BaseHttpError
- RangeNotSatisfiedHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Range Not Satisfied Http Error(message?, options?): RangeNotSatisfiedHttpError Default message is 'The requested range is not supported.'.
-Parameters
Optionalmessage: stringOptional, more specific, message.
-Optionaloptions: HttpErrorOptionsOptional error options.
-
Returns RangeNotSatisfiedHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class RangePreferenceParser
Parses the range header into range preferences.
-If the range corresponds to a suffix-length range, it will be stored in start as a negative value.
Hierarchy (view full)
- PreferenceParser
- RangePreferenceParser
Index
Constructors
Methods
Constructors
constructor
- new
Range Preference Parser(): RangePreferenceParser Returns RangePreferenceParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<RepresentationPreferences>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<RepresentationPreferences> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class RawBodyParser
Converts incoming HttpRequest to a Representation without any further parsing.
-Hierarchy (view full)
- BodyParser
- RawBodyParser
Index
Constructors
constructor
- new
Raw Body Parser(): RawBodyParser Returns RawBodyParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: BodyParserArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: BodyParserArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: BodyParserArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: BodyParserArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
Class RdfPatcher
Patcher that converts the representation data to a representation with an N3 store, does the patch using this store -and then converts the representation with store back to a representation with data which gets returned
-Hierarchy (view full)
- RepresentationPatcher<Representation>
- RdfPatcher
Index
Constructors
constructor
- new
Rdf Patcher(patcher): RdfPatcher Parameters
- patcher: RepresentationPatcher<RdfDatasetRepresentation>
Returns RdfPatcher
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<Representation>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<Representation>
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<Representation>
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<Representation>
Class RdfStorePatcherAbstract
Applies a Patch on an N3.js Store.
-Hierarchy (view full)
- AsyncHandler<RdfStorePatcherInput, Store>
- RdfStorePatcher
Index
Constructors
Methods
Constructors
constructor
- new
Rdf Store Patcher(): RdfStorePatcher Returns RdfStorePatcher
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RdfStorePatcherInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RdfStorePatcherInput
Abstracthandle
- handle(input): Promise<Store<Quad, Quad, Quad, Quad>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RdfStorePatcherInput
Input that needs to be handled.
-
Returns Promise<Store<Quad, Quad, Quad, Quad>>
A promise resolving when handling is finished.
-- input: RdfStorePatcherInput
handle
- handle
Safe(input): Promise<Store<Quad, Quad, Quad, Quad>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RdfStorePatcherInput
Input data that will be handled if it can be handled.
-
Returns Promise<Store<Quad, Quad, Quad, Quad>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RdfStorePatcherInput
Class RdfToQuadConverter
Converts most major RDF serializations to internal/quads.
Custom contexts can be defined to be used when parsing JSON-LD. -The keys of the object should be the URL of the context, -and the values the file path of the contexts to use when the JSON-LD parser would fetch the given context. -We use filepaths because embedding them directly into the configurations breaks Components.js.
-Hierarchy (view full)
- BaseTypedRepresentationConverter
- RdfToQuadConverter
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Rdf To Quad Converter(contexts?): RdfToQuadConverter Parameters
- contexts: Record<string, string> = {}
Returns RdfToQuadConverter
Methods
can
- can
Handle(args): Promise<void> Determines whether the given conversion request is supported, -given the available content type conversions:
--
-
- Checks if there is a content type for the input. -
- Checks if the input type is supported by the parser. -
- Checks if the parser can produce one of the preferred output types. -Throws an error with details if conversion is not possible. -
Parameters
Returns Promise<void>
get
- get
Output Types(contentType): Promise<ValuePreferences> Matches all inputs to all outputs.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class RdfValidator
Validates a Representation by verifying if the data stream contains valid RDF data. -It does this by letting the stored RepresentationConverter convert the data.
-Hierarchy (view full)
- Validator
- RdfValidator
Index
Constructors
constructor
- new
Rdf Validator(converter): RdfValidator Parameters
- converter: RepresentationConverter
Returns RdfValidator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ValidatorInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
handle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ValidatorInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: ValidatorInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ValidatorInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
Class ReadOnlyStore<T>
Store that only allow read operations on the underlying source.
-Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- PassthroughStore<T>
- ReadOnlyStore
Index
Constructors
constructor
- new
Read Only Store<T>(source): ReadOnlyStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
Returns ReadOnlyStore<T>
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class RecordObject
Helper class for instantiating multiple objects with Components.js. -See https://github.com/LinkedSoftwareDependencies/Components.js/issues/26
-Implements
- Record<string, unknown>
Indexable
- [key: string]: unknown
Index
Constructors
Constructors
constructor
- new
Record Object(record?): RecordObject Parameters
- record: Record<string, unknown> = {}
Returns RecordObject
Class RedirectHttpError<TCode>
An error corresponding to a 3xx status code. -Includes the location it redirects to.
-Type Parameters
Hierarchy (view full)
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Redirect Http Error<TCode>(statusCode, name, location, message?, options?): RedirectHttpError<TCode> Type Parameters
Parameters
- statusCode: TCode
- name: string
- location: string
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns RedirectHttpError<TCode>
Properties
Optional Readonlycause
Readonlyerror
Readonlylocation
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Optionalprepare
Optional override for formatting stack traces
-Staticstack
Methods
Protectedgenerate
Staticcapture
Staticis
- is
Instance(error): error is RedirectHttpError<number> Parameters
- error: unknown
Returns error is RedirectHttpError<number>
Class RedirectingErrorHandler
Internally we create redirects by throwing specific RedirectHttpErrors. -This Error handler converts those to RedirectResponseDescriptions that are used for output.
-Hierarchy (view full)
- ErrorHandler
- RedirectingErrorHandler
Index
Constructors
Methods
Constructors
constructor
- new
Redirecting Error Handler(): RedirectingErrorHandler Returns RedirectingErrorHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ErrorHandlerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ErrorHandlerArgs
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: ErrorHandlerArgs
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ErrorHandlerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Class RedirectingHttpHandler
Handler that redirects paths matching given patterns -to their corresponding URL, substituting selected groups.
-Hierarchy (view full)
- HttpHandler
- RedirectingHttpHandler
Index
Constructors
Methods
Constructors
constructor
- new
Redirecting Http Handler(redirects, baseUrl, targetExtractor, responseWriter, statusCode?): RedirectingHttpHandler Creates a handler for the provided redirects.
-Parameters
- redirects: Record<string, string>
A mapping between URL patterns.
- - baseUrl: string
Base URL of the server.
- - targetExtractor: TargetExtractor
To extract the target from the request.
- - responseWriter: ResponseWriter
To write the redirect to the response.
- - statusCode:
| 301
| 302
| 303
| 307
| 308 = 308Desired 30x redirection code (defaults to 308).
-
Returns RedirectingHttpHandler
- redirects: Record<string, string>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class RedisLocker
A Redis Locker that can be used as both:
--
-
- a Read Write Locker that uses a (single) Redis server to store the locks and counts. -
- a Resource Locker that uses a (single) Redis server to store the lock. -This solution should be process-safe. The only references to locks are string keys -derived from identifier paths. -
The Read Write algorithm roughly goes as follows:
--
-
- Acquire a read lock: allowed as long as there is no write lock. On acquiring the read counter goes up. -
- Acquire a write lock: allowed as long as there is no other write lock AND the read counter is 0. -
- Release a read lock: decreases the read counter with 1 -
- Release a write lock: unlocks the write lock -
The Resource locking algorithm uses a single mutex/lock.
-All operations, such as checking for a write lock AND read count, are executed in a single Lua script. -These scripts are used by Redis as a single new command. -Redis executes its operations in a single thread, as such, each such operation can be considered atomic.
-The operation to (un)lock will always resolve with either 1/OK/true if succeeded or 0/false if not succeeded. -Rejection with errors will be happen on actual failures. Retrying the (un)lock operations will be done by making -use of the LockUtils' retryFunctionUntil function.
--
-
-
Implements
Index
Constructors
constructor
- new
Redis Locker(redisClient?, attemptSettings?, redisSettings?): RedisLocker Creates a new RedisClient
-Parameters
- redisClient: string = '127.0.0.1:6379'
Redis connection string of a standalone Redis node
- - attemptSettings: AttemptSettings = {}
Override default AttemptSettings
- OptionalredisSettings: RedisSettingsAddition settings used to create the Redis client or to interact with the Redis server
-
Returns RedisLocker
- redisClient: string = '127.0.0.1:6379'
Methods
acquire
- acquire(identifier): Promise<void>
Acquires a lock on the requested identifier. -The promise will resolve when the lock has been acquired.
-Parameters
- identifier: ResourceIdentifier
Resource to acquire a lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
finalize
initialize
release
- release(identifier): Promise<void>
Releases a lock on the requested identifier. -The promise will resolve when the lock has been released. -If there is no lock on the resource, an error should be thrown.
-Parameters
- identifier: ResourceIdentifier
Resource to release the lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Class RegexRouterRule
Routes requests to a store based on the path of the identifier.
-The identifier will be stripped of the base URI after which regexes will be used to find the correct store.
-The trailing slash of the base URI will still be present so the first character a regex can match would be that /.
-This way regexes such as /container/ can match containers in any position.
In case none of the regexes match an error will be thrown.
-Hierarchy (view full)
- RouterRule
- RegexRouterRule
Index
Constructors
Methods
Constructors
constructor
- new
Regex Router Rule(base, rules): RegexRouterRule The keys of the
-storeMapwill be converted into actual RegExp objects that will be used for testing.Parameters
- base: string
- rules: RegexRule[]
Returns RegexRouterRule
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<ResourceStore>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
}Input that needs to be handled.
-identifier: ResourceIdentifier
Returns Promise<ResourceStore>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceStore> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class RegexRule
Utility class to easily configure Regex to ResourceStore mappings in the config files.
- Index
Constructors
Properties
Constructors
constructor
- new
Regex Rule(regex, store): RegexRule Parameters
- regex: string
- store: ResourceStore
Returns RegexRule
Class RelativePathInteractionRoute<TBase>
A route that is relative to another route. -The relative path will be joined to the input base, -which can either be an absolute URL or an InteractionRoute of which the path will be used.
-Type Parameters
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Relative Path Interaction Route<TBase>(base, relativePath, ensureSlash?): RelativePathInteractionRoute<TBase> Type Parameters
Parameters
- base: InteractionRoute<TBase>
- relativePath: string
- ensureSlash: boolean = true
Returns RelativePathInteractionRoute<TBase>
Methods
get
- get
Path(parameters?): string Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input
-parametersobject is missing one of the expected keys.Parameters
Optionalparameters: Record<TBase, string>Values for the dynamic parameters.
-
Returns string
match
- match
Path(path): undefined | Record<TBase, string> Checks if the provided path matches the route (pattern).
-The result will be
-undefinedif there is no match.If there is a match the result object will have the corresponding values for all the parameters.
-Parameters
- path: string
The path to verify.
-
Returns undefined | Record<TBase, string>
- path: string
Class RepresentationConverterAbstract
Converts a Representation from one media type to another, based on the given preferences.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Representation Converter(): RepresentationConverter Returns RepresentationConverter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class RepresentationConvertingStore<T>
Store that provides (optional) conversion of incoming and outgoing Representations.
-Type Parameters
- T extends ResourceStore = ResourceStore
Hierarchy (view full)
- PassthroughStore<T>
- RepresentationConvertingStore
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Representation Converting Store<T>(source, metadataStrategy, options): RepresentationConvertingStore<T> Type Parameters
- T extends ResourceStore = ResourceStore
Parameters
- source: T
Store we retrieve data from and send data to.
- - metadataStrategy: AuxiliaryStrategy
Used to distinguish regular resources (which may be converted) -from metadata resources (which always need conversion).
- - options: {
inConverter?: RepresentationConverter;
inPreferences?: RepresentationPreferences;
outConverter?: RepresentationConverter;
}Determines when data should be converted.
-OptionalinConverter?: RepresentationConverter Converts data before passing to the source store.
-OptionalinPreferences?: RepresentationPreferences The preferred input format for the source store, as passed to the inConverter.
-OptionaloutConverter?: RepresentationConverter Converts data after retrieval from the source store.
-
Returns RepresentationConvertingStore<T>
Methods
add
- add
Resource(identifier, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- identifier: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class RepresentationMetadata
Stores the metadata triples and provides methods for easy access. -Most functions return the metadata object to allow for chaining.
- Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
- new
Representation Metadata(identifier?, overrides?): RepresentationMetadata Parameters
Optionalidentifier: MetadataIdentifierIdentifier of the resource relevant to this metadata. -A blank node will be generated if none is provided. -Strings will be converted to named nodes.
-Optionaloverrides: MetadataRecordKey/value map of extra values that need to be added to the metadata.
-
Returns RepresentationMetadata
- new
Representation Metadata(metadata?, overrides?): RepresentationMetadata Parameters
Optionalmetadata: RepresentationMetadataStarts as a copy of the input metadata.
-Optionaloverrides: MetadataRecordKey/value map of extra values that need to be added to the metadata. -Will override values that were set by the input metadata.
-
Returns RepresentationMetadata
- new
Representation Metadata(identifier?, contentType?): RepresentationMetadata Parameters
Optionalidentifier: MetadataIdentifierIdentifier of the resource relevant to this metadata.
-OptionalcontentType: string | ContentTypeOverride for the content type of the representation.
-
Returns RepresentationMetadata
- new
Representation Metadata(metadata?, contentType?): RepresentationMetadata Parameters
Optionalmetadata: RepresentationMetadataStarts as a copy of the input metadata.
-OptionalcontentType: string | ContentTypeOverride for the content type of the representation.
-
Returns RepresentationMetadata
- new
Representation Metadata(contentType?): RepresentationMetadata Parameters
OptionalcontentType: string | ContentTypeThe content type of the representation.
-
Returns RepresentationMetadata
- new
Representation Metadata(metadata?): RepresentationMetadata Parameters
Optionalmetadata: string | MetadataRecord | RepresentationMetadataMetadata values (defaulting to content type if a string)
-
Returns RepresentationMetadata
Accessors
content
- get contentLength(): undefined | number
Shorthand for the CONTENT_LENGTH predicate.
-Returns undefined | number
- set contentLength(input): void
Parameters
- input: undefined | number
Returns void
content
- get contentType(): undefined | string
Shorthand for the CONTENT_TYPE predicate.
-Returns undefined | string
- set contentType(input): void
Parameters
- input: undefined | string
Returns void
content
- get contentTypeObject(): undefined | ContentType
Shorthand for the ContentType as an object (with parameters)
-Returns undefined | ContentType
- set contentTypeObject(contentType): void
Parameters
- contentType: undefined | ContentType
Returns void
identifier
- get identifier(): BlankNode | NamedNode<string>
Identifier of the resource this metadata is relevant to. -Will update all relevant triples if this value gets changed.
-Returns BlankNode | NamedNode<string>
- set identifier(id): void
Parameters
- id: BlankNode | NamedNode<string>
Returns void
Methods
add
- add(predicate, object, graph?): this
Adds a value linked to the identifier. Strings get converted to literals.
-Parameters
- predicate: NamedNode<string>
Predicate linking identifier to value.
- - object: MetadataValue
Value(s) to add.
- Optionalgraph: MetadataGraphOptional graph of where to add the values to.
-
Returns this
- predicate: NamedNode<string>
add
- add
Quad(subject, predicate, object, graph?): this Parameters
- subject: string | BlankNode | NamedNode<string>
Subject of quad to add.
- - predicate: NamedNode<string>
Predicate of quad to add.
- - object:
| string
| BlankNode
| Literal
| NamedNode<string>Object of quad to add.
- Optionalgraph: MetadataGraphOptional graph of quad to add.
-
Returns this
- subject: string | BlankNode | NamedNode<string>
add
get
- get(predicate, graph?): undefined | Term
Parameters
- predicate: NamedNode<string>
Predicate to get the value for.
- Optionalgraph: MetadataGraphOptional graph where the triple should be found.
-
Returns undefined | Term
The corresponding value. Undefined if there is no match
-- predicate: NamedNode<string>
get
- get
All(predicate, graph?): Term[] Finds all object values matching the given predicate and/or graph.
-Parameters
- predicate: NamedNode<string>
Optional predicate to get the values for.
- Optionalgraph: MetadataGraphOptional graph where to get from.
-
Returns Term[]
An array with all matches.
-- predicate: NamedNode<string>
has
- has(predicate?, object?, graph?): boolean
Verifies if a specific triple can be found in the metadata. -Undefined parameters are interpreted as wildcards.
-Parameters
- predicate: null | string | NamedNode<string> = null
- object:
| null
| string
| BlankNode
| Literal
| NamedNode<string> = null - graph: null | MetadataGraph = null
Returns boolean
quads
- quads(subject?, predicate?, object?, graph?): Quad[]
Parameters
- subject:
| null
| string
| BlankNode
| NamedNode<string> = null - predicate: null | NamedNode<string> = null
- object:
| null
| string
| BlankNode
| Literal
| NamedNode<string> = null - graph: null | MetadataGraph = null
Returns Quad[]
All matching metadata quads.
-- subject:
remove
- remove(predicate, object, graph?): this
Removes the given value from the metadata. Strings get converted to literals.
-Parameters
- predicate: NamedNode<string>
Predicate linking identifier to value.
- - object: MetadataValue
Value(s) to remove.
- Optionalgraph: MetadataGraphOptional graph of where to remove the values from.
-
Returns this
- predicate: NamedNode<string>
remove
- remove
All(predicate, graph?): this Removes all values linked through the given predicate.
-Parameters
- predicate: NamedNode<string>
Predicate to remove.
- Optionalgraph: MetadataGraphOptional graph where to remove from.
-
Returns this
- predicate: NamedNode<string>
remove
- remove
Quad(subject, predicate, object, graph?): this Parameters
- subject: string | BlankNode | NamedNode<string>
Subject of quad to remove.
- - predicate: NamedNode<string>
Predicate of quad to remove.
- - object:
| string
| BlankNode
| Literal
| NamedNode<string>Object of quad to remove.
- Optionalgraph: MetadataGraphOptional graph of quad to remove.
-
Returns this
- subject: string | BlankNode | NamedNode<string>
remove
set
- set(predicate, object?, graph?): this
Sets the value for the given predicate, removing all other instances. -In case the object is undefined this is identical to
-removeAll(predicate).Parameters
- predicate: NamedNode<string>
Predicate linking to the value.
- Optionalobject: MetadataValueValue(s) to set.
-Optionalgraph: MetadataGraphOptional graph where the triple should be stored.
-
Returns this
- predicate: NamedNode<string>
set
- set
Metadata(metadata): this Helper function to import all entries from the given metadata. -If the new metadata has a different identifier the internal one will be updated.
-Parameters
- metadata: RepresentationMetadata
Metadata to import.
-
Returns this
- metadata: RepresentationMetadata
Class RepresentationPatchHandler
Handles a patch operation by getting the representation from the store, applying a RepresentationPatcher,
-and then writing the result back to the store.
In case there is no original representation (the store throws a NotFoundHttpError),
-the patcher is expected to create a new one.
Hierarchy (view full)
- PatchHandler
- RepresentationPatchHandler
Index
Constructors
constructor
- new
Representation Patch Handler(patcher): RepresentationPatchHandler Parameters
- patcher: RepresentationPatcher<Representation>
Returns RepresentationPatchHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PatchHandlerInput<ResourceStore>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PatchHandlerInput<ResourceStore>
handle
- handle(input): Promise<ChangeMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PatchHandlerInput
Input that needs to be handled.
-
Returns Promise<ChangeMap>
A promise resolving when handling is finished.
-- input: PatchHandlerInput
handle
- handle
Safe(input): Promise<ChangeMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PatchHandlerInput<ResourceStore>
Input data that will be handled if it can be handled.
-
Returns Promise<ChangeMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PatchHandlerInput<ResourceStore>
Class RepresentationPatcher<T>Abstract
Handles the patching of a specific Representation.
-Type Parameters
Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Representation Patcher<T>(): RepresentationPatcher<T> Type Parameters
Returns RepresentationPatcher<T>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<T>
Abstracthandle
- handle(input): Promise<T>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<T>
Input that needs to be handled.
-
Returns Promise<T>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<T>
handle
- handle
Safe(input): Promise<T> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<T>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<T>
Class RequestParserAbstract
Converts an incoming HttpRequest to an Operation.
-Hierarchy (view full)
- AsyncHandler<HttpRequest, Operation>
- RequestParser
Index
Constructors
Methods
Constructors
constructor
- new
Request Parser(): RequestParser Returns RequestParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Abstracthandle
- handle(input): Promise<Operation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpRequest
Input that needs to be handled.
-
Returns Promise<Operation>
A promise resolving when handling is finished.
-- input: HttpRequest
handle
- handle
Safe(input): Promise<Operation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Operation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class ResetPasswordHandler
Resets a password if a valid recordId is provided,
-which should have been generated by a different handler.
Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- ResetPasswordHandler
Implements
Index
Constructors
constructor
- new
Reset Password Handler(passwordStore, forgotPasswordStore): ResetPasswordHandler Parameters
- passwordStore: PasswordStore
- forgotPasswordStore: ForgotPasswordStore
Returns ResetPasswordHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(): Promise<JsonRepresentation<Dict<Json>>> Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ResetResponseDescription
Corresponds to a 205 response.
-Hierarchy (view full)
- ResponseDescription
- ResetResponseDescription
Index
Constructors
Properties
Constructors
constructor
- new
Reset Response Description(): ResetResponseDescription Returns ResetResponseDescription
Class ResolveLoginHandlerAbstract
A handler that takes care of all the necessary steps when logging a user in,
-such as generating a cookie and setting the necessary OIDC information.
-Classes that resolve login methods should extend this class and implement the login method.
Hierarchy (view full)
- JsonInteractionHandler
- ResolveLoginHandler
Index
Constructors
Properties
Methods
Constructors
Protectedconstructor
- new
Resolve Login Handler(accountStore, cookieStore): ResolveLoginHandler Parameters
- accountStore: AccountStore
- cookieStore: CookieStore
Returns ResolveLoginHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Abstractlogin
- login(input): Promise<JsonRepresentation<LoginOutputType>>
Takes the necessary steps to log a user in.
-Parameters
- input: JsonInteractionHandlerInput
Same input that was passed to the handle function.
-
Returns Promise<JsonRepresentation<LoginOutputType>>
- input: JsonInteractionHandlerInput
Protectedupdate
- update
Remember Setting(accountId, remember?): Promise<void> Updates the account setting that determines whether the login status needs to be remembered.
-Parameters
- accountId: string
ID of the account.
- Optionalremember: booleanIf the account should be remembered or not. The setting will not be updated if this is undefined.
-
Returns Promise<void>
- accountId: string
Class ResponseDescription
The result of executing an operation.
-Hierarchy (view full)
- ResponseDescription
Index
Constructors
Properties
Constructors
constructor
- new
Response Description(statusCode, metadata?, data?): ResponseDescription Parameters
- statusCode: number
Status code to return.
- Optionalmetadata: RepresentationMetadataMetadata corresponding to the response (and data potentially).
-Optionaldata: Guarded<Readable>Data that needs to be returned.
-
Returns ResponseDescription
- statusCode: number
Class ResponseWriterAbstract
Writes the ResponseDescription to the HttpResponse.
-Hierarchy (view full)
- AsyncHandler<{
response: HttpResponse;
result: ResponseDescription;
}>- ResponseWriter
Index
Constructors
Methods
Constructors
constructor
- new
Response Writer(): ResponseWriter Returns ResponseWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input that could potentially be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input that needs to be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
response: HttpResponse;
result: ResponseDescription;
}Input data that will be handled if it can be handled.
-response: HttpResponse
result: ResponseDescription
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class RootFilePathHandler
Uses a FileIdentifierMapper to generate a root file path variable based on the identifier. -Will throw an error if the resulting file path already exists.
-Hierarchy (view full)
- VariableHandler
- RootFilePathHandler
Index
Constructors
Methods
Constructors
constructor
- new
Root File Path Handler(fileMapper): RootFilePathHandler Parameters
- fileMapper: FileIdentifierMapper
Returns RootFilePathHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that needs to be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class RootStorageLocationStrategy
A StorageLocationStrategy to be used when the server has one storage in the root container of the server.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Root Storage Location Strategy(baseUrl): RootStorageLocationStrategy Parameters
- baseUrl: string
Returns RootStorageLocationStrategy
Methods
get
- get
Storage Identifier(): Promise<ResourceIdentifier> Returns the identifier of the storage that contains the given resource. -Can error if the input identifier is not part of any storage.
-Returns Promise<ResourceIdentifier>
Class RouterHandler
A BaseRouterHandler for an HttpHandler. -Uses a TargetExtractor to generate the target identifier.
-Hierarchy (view full)
- BaseRouterHandler<HttpHandler>
- RouterHandler
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Router Handler(args): RouterHandler Parameters
- args: RouterHandlerArgs
Returns RouterHandler
Properties
Protected Readonlyall
Protected Readonlyallowed
Protected Readonlyallowed
Protected Readonlybase
Protected Readonlyhandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Protectedcan
- can
Handle Input(input, method, target): Promise<void> Parameters
- input: HttpHandlerInput
- method: string
- target: ResourceIdentifier
Returns Promise<void>
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class RouterRuleAbstract
Finds which store needs to be accessed for the given resource, -potentially based on the Representation of incoming data.
-Hierarchy (view full)
- AsyncHandler<{
identifier: ResourceIdentifier;
representation?: Representation;
}, ResourceStore>
Index
Constructors
Methods
Constructors
constructor
- new
Router Rule(): RouterRule Returns RouterRule
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<ResourceStore>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input that needs to be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceStore> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
representation?: Representation;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
Optionalrepresentation?: Representation
Returns Promise<ResourceStore>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class RoutingAuxiliaryIdentifierStrategy
An AuxiliaryIdentifierStrategy that combines multiple AuxiliaryIdentifierStrategies into one.
-Uses isAuxiliaryIdentifier to know which strategy to route to.
Hierarchy (view full)
- RoutingAuxiliaryIdentifierStrategy
Implements
Index
Constructors
constructor
- new
Routing Auxiliary Identifier Strategy(sources): RoutingAuxiliaryIdentifierStrategy Parameters
- sources: AuxiliaryIdentifierStrategy[]
Returns RoutingAuxiliaryIdentifierStrategy
Methods
get
- get
Auxiliary Identifier(): never Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Returns never
The ResourceIdentifier of the corresponding auxiliary resource.
-
get
- get
Auxiliary Identifiers(identifier): ResourceIdentifier[] Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
Protectedget
- get
Matching Source(identifier): AuxiliaryIdentifierStrategy Parameters
- identifier: ResourceIdentifier
Returns AuxiliaryIdentifierStrategy
get
- get
Subject Identifier(identifier): ResourceIdentifier Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
- is
Auxiliary Identifier(identifier): boolean Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
Class RoutingAuxiliaryStrategy
An AuxiliaryStrategy that combines multiple AuxiliaryStrategies into one.
-Uses isAuxiliaryIdentifier to know which strategy to call for which call.
addMetadata will either call all strategies if the input is the subject identifier,
-or only the matching strategy if the input is an auxiliary identifier.
Hierarchy (view full)
- RoutingAuxiliaryIdentifierStrategy
- RoutingAuxiliaryStrategy
Implements
Index
Constructors
constructor
- new
Routing Auxiliary Strategy(sources): RoutingAuxiliaryStrategy Parameters
- sources: AuxiliaryStrategy[]
Returns RoutingAuxiliaryStrategy
Methods
add
- add
Metadata(metadata): Promise<void> Adds metadata related to this auxiliary resource, -in case this is required for this type of auxiliary resource. -The metadata that is added depends on the given identifier being an auxiliary or subject resource: -the metadata will be used to link to the other one, and potentially add extra typing info.
-Used for: -Solid, §4.3.1: "For any defined auxiliary resource available for a given Solid resource, all representations of -that resource MUST include an HTTP Link header pointing to the location of each auxiliary resource." -https://solid.github.io/specification/protocol#auxiliary-resources-server
-The above is an example of how that metadata would only be added in case the input is the subject identifier.
-Parameters
- metadata: RepresentationMetadata
Metadata to update.
-
Returns Promise<void>
- metadata: RepresentationMetadata
get
- get
Auxiliary Identifier(): never Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Returns never
The ResourceIdentifier of the corresponding auxiliary resource.
-
get
- get
Auxiliary Identifiers(identifier): ResourceIdentifier[] Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
Protectedget
- get
Matching Source(identifier): AuxiliaryStrategy Parameters
- identifier: ResourceIdentifier
Returns AuxiliaryStrategy
get
- get
Subject Identifier(identifier): ResourceIdentifier Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
- is
Auxiliary Identifier(identifier): boolean Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
is
- is
Required In Root(identifier): boolean Whether the root storage container requires this auxiliary resource to be present. -If yes, this means they can't be deleted individually from such a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns boolean
- identifier: ResourceIdentifier
uses
- uses
Own Authorization(identifier): boolean Whether this auxiliary resources uses its own authorization instead of the subject resource authorization.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns boolean
- identifier: ResourceIdentifier
validate
- validate(representation): Promise<void>
Validates if the representation contains valid data for an auxiliary resource. -Should throw an error in case the data is invalid.
-Parameters
- representation: Representation
Representation of the auxiliary resource.
-
Returns Promise<void>
- representation: Representation
Class RoutingResourceStore
Store that routes the incoming request to a specific store based on the stored ResourceRouter. -In case no store was found for one of the functions that take no data (GET/PATCH/DELETE), -a 404 will be thrown. In the other cases the error of the router will be thrown (which would probably be 400).
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Routing Resource Store(rule): RoutingResourceStore Parameters
- rule: RouterRule
Returns RoutingResourceStore
Methods
add
- add
Resource(container, representation, conditions?): Promise<ChangeMap> Creates a new resource in the container.
-Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
- delete
Resource(identifier, conditions?): Promise<ChangeMap> Deletes a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
- get
Representation(identifier, preferences, conditions?): Promise<Representation> Retrieves a representation of a resource.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
- has
Resource(identifier): Promise<boolean> Checks whether a resource exists in this ResourceSet.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
- modify
Resource(identifier, patch, conditions?): Promise<ChangeMap> Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
- set
Representation(identifier, representation, conditions?): Promise<ChangeMap> Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Class SafeErrorHandler
Returns a simple text description of an error. -This class is a failsafe in case the wrapped error handler fails.
-Hierarchy (view full)
- ErrorHandler
- SafeErrorHandler
Index
Constructors
constructor
- new
Safe Error Handler(errorHandler, showStackTrace?): SafeErrorHandler Parameters
- errorHandler: ErrorHandler
- showStackTrace: boolean = false
Returns SafeErrorHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ErrorHandlerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ErrorHandlerArgs
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: ErrorHandlerArgs
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ErrorHandlerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Class SeededAccountInitializer
Initializes a set of accounts based on the input data. -These accounts have exactly 1 email/password login method, and 0 or more pods. -The pod settings that can be defined are identical to those of the CreatePodHandler.
-Hierarchy (view full)
- Initializer
- SeededAccountInitializer
Index
Constructors
constructor
- new
Seeded Account Initializer(args): SeededAccountInitializer Parameters
Returns SeededAccountInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class SequenceHandler<TIn, TOut>
A composite handler that will try to run all supporting handlers sequentially
-and return the value of the last supported handler.
-The canHandle check of this handler will always succeed.
Type Parameters
Hierarchy (view full)
- AsyncHandler<TIn, TOut | undefined>
- SequenceHandler
Index
Constructors
Methods
Constructors
constructor
- new
Sequence Handler<TIn, TOut>(handlers): SequenceHandler<TIn, TOut> Type Parameters
Parameters
- handlers: AsyncHandler<TIn, TOut>[]
Returns SequenceHandler<TIn, TOut>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TIn
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
handle
- handle(input): Promise<undefined | TOut>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TIn
Input that needs to be handled.
-
Returns Promise<undefined | TOut>
A promise resolving when handling is finished.
-- input: TIn
handle
- handle
Safe(input): Promise<undefined | TOut> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TIn
Input data that will be handled if it can be handled.
-
Returns Promise<undefined | TOut>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TIn
Class ServerConfiguratorAbstract
Configures a Server by attaching listeners for specific events.
-Hierarchy (view full)
- AsyncHandler<Server>
- ServerConfigurator
Index
Constructors
Methods
Constructors
constructor
- new
Server Configurator(): ServerConfigurator Returns ServerConfigurator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
Class ServerInitializer
Creates and starts an HTTP server.
-Hierarchy (view full)
- Initializer
- ServerInitializer
Implements
Index
Constructors
constructor
- new
Server Initializer(serverFactory, port?, socketPath?): ServerInitializer Parameters
- serverFactory: HttpServerFactory
Optionalport: numberOptionalsocketPath: string
Returns ServerInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
finalize
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class ShorthandExtractorAbstract
A handler that computes a specific value from a given map of values.
-Hierarchy (view full)
- AsyncHandler<Shorthand, unknown>
- ShorthandExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Shorthand Extractor(): ShorthandExtractor Returns ShorthandExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Abstracthandle
- handle(input): Promise<unknown>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Shorthand
Input that needs to be handled.
-
Returns Promise<unknown>
A promise resolving when handling is finished.
-- input: Shorthand
handle
- handle
Safe(input): Promise<unknown> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<unknown>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class ShorthandResolverAbstract
Converts a key/value object, extracted from the CLI or passed as a parameter, -into a new key/value object where the keys are variables defined in the Components.js configuration. -The resulting values are the values that should be assigned to those variables.
-Hierarchy (view full)
- AsyncHandler<Shorthand, VariableBindings>
- ShorthandResolver
Index
Constructors
Methods
Constructors
constructor
- new
Shorthand Resolver(): ShorthandResolver Returns ShorthandResolver
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Shorthand
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Abstracthandle
- handle(input): Promise<VariableBindings>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Shorthand
Input that needs to be handled.
-
Returns Promise<VariableBindings>
A promise resolving when handling is finished.
-- input: Shorthand
handle
- handle
Safe(input): Promise<VariableBindings> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Shorthand
Input data that will be handled if it can be handled.
-
Returns Promise<VariableBindings>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Shorthand
Class SingleContainerJsonStorage<T>
A variant of a JsonResourceStorage where the entries() call
-does not recursively iterate through all containers.
-Only the documents that are found in the root container are returned.
This class was created to support migration where different storages are nested in one main .internal container,
-and we specifically want to only return entries of one storage.
Type Parameters
Hierarchy (view full)
- JsonResourceStorage<T>
- SingleContainerJsonStorage
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Single Container Json Storage<T>(source, baseUrl, container): SingleContainerJsonStorage<T> Type Parameters
Parameters
- source: ResourceStore
- baseUrl: string
- container: string
Returns SingleContainerJsonStorage<T>
Properties
Protected Readonlycontainer
Protected Readonlylogger
Protected Readonlysource
Methods
delete
entries
get
Protectedget
- get
Resource Entries(containerId): AsyncIterableIterator<[string, T]> Recursively iterates through the container to find all documents.
-Parameters
- containerId: ResourceIdentifier
Returns AsyncIterableIterator<[string, T]>
has
Protectedidentifier
- identifier
To Key(identifier): string Converts an internal identifier to an external key.
-Parameters
- identifier: ResourceIdentifier
Returns string
Protectedkey
- key
To Identifier(key): ResourceIdentifier Converts a key into an identifier for internal storage.
-Parameters
- key: string
Returns ResourceIdentifier
Protectedsafely
- safely
Get Resource(identifier): Promise<undefined | Representation> Returns the representation for the given identifier. -Returns undefined if a 404 error is thrown. -Re-throws the error in all other cases.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<undefined | Representation>
set
- set(key, value): Promise<SingleContainerJsonStorage<T>>
Sets the value for the given key.
-Parameters
- key: string
Key to set/update.
- - value: unknown
Value to store.
-
Returns Promise<SingleContainerJsonStorage<T>>
The storage.
-- key: string
Class SingleRootIdentifierStrategy
An IdentifierStrategy that assumes there is only 1 root and all other identifiers are made by appending to that root.
-Hierarchy (view full)
- BaseIdentifierStrategy
- SingleRootIdentifierStrategy
Index
Constructors
constructor
- new
Single Root Identifier Strategy(baseUrl): SingleRootIdentifierStrategy Parameters
- baseUrl: string
Returns SingleRootIdentifierStrategy
Methods
contains
- contains(container, identifier, transitive): boolean
Checks if the given container would contain the given identifier. -This does not check that either of these identifiers actually exist. -This is similar to calling getParentContainer on an identifier -and comparing the result.
-If
-transitiveisfalsethis only checks ifcontaineris the direct parent container ofidentifier.Parameters
- container: ResourceIdentifier
- identifier: ResourceIdentifier
- transitive: boolean
Returns boolean
get
- get
Parent Container(identifier): ResourceIdentifier Generates the identifier of the container this resource would be a member of. -This does not check if that identifier actually exists. -Will throw an error if the input identifier is a root container or is not supported.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
is
- is
Root Container(identifier): boolean Checks if the input corresponds to the identifier of a root container. -This does not check if this identifier actually exists.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
supports
- supports
Identifier(identifier): boolean Verifies if this identifier is supported. -This does not check if this identifier actually exists, -but checks if the identifier is in scope for this class.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
Class SliceStream
A stream that slices a part out of another stream.
-start and end are inclusive.
-If end is not defined it is until the end of the stream.
Negative start values can be used to instead slice that many streams off the end of the stream.
-This requires the size field to be defined.
Both object and non-object streams are supported. -This needs to be explicitly specified, -as the class makes no assumptions based on the object mode of the source stream.
-Hierarchy
- Transform
- SliceStream
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Slice Stream(source, options): SliceStream Parameters
- source: Readable
- options: SliceStreamOptions
Returns SliceStream
Properties
allow
If false then the stream will automatically end the writable side when the
-readable side ends. Set initially by the allowHalfOpen constructor option,
-which defaults to false.
This can be changed manually to change the half-open behavior of an existingDuplex stream instance, but must be changed before the 'end' event is
-emitted.
Readonlyclosed
Is true after 'close' has been emitted.
-destroyed
Is true after readable.destroy() has been called.
Readonlyerrored
Returns error if the stream has been destroyed with an error.
-readable
Is true if it is safe to call readable.read(), which means
-the stream has not been destroyed or emitted 'error' or 'end'.
Readonly Experimentalreadable
Returns whether the stream was destroyed or errored before emitting 'end'.
Readonly Experimentalreadable
Returns whether 'data' has been emitted.
Readonlyreadable
Getter for the property encoding of a given Readable stream. The encodingproperty can be set using the readable.setEncoding() method.
Readonlyreadable
Becomes true when 'end' event is emitted.
Readonlyreadable
This property reflects the current state of a Readable stream as described
-in the Three states section.
Readonlyreadable
Returns the value of highWaterMark passed when creating this Readable.
Readonlyreadable
This property contains the number of bytes (or objects) in the queue
-ready to be read. The value provides introspection data regarding
-the status of the highWaterMark.
Readonlyreadable
Getter for the property objectMode of a given Readable stream.
Protectedremaining
Protectedremaining
Protected Readonlysource
Readonlywritable
Is true if it is safe to call writable.write(), which means
-the stream has not been destroyed, errored or ended.
Readonlywritable
Number of times writable.uncork() needs to be
-called in order to fully uncork the stream.
Readonlywritable
Is true after writable.end() has been called. This property
-does not indicate whether the data has been flushed, for this use writable.writableFinished instead.
Readonlywritable
Is set to true immediately before the 'finish' event is emitted.
Readonlywritable
Return the value of highWaterMark passed when creating this Writable.
Readonlywritable
This property contains the number of bytes (or objects) in the queue
-ready to be written. The value provides introspection data regarding
-the status of the highWaterMark.
Readonlywritable
Is true if the stream's buffer has been full and stream will emit 'drain'.
Readonlywritable
Getter for the property objectMode of a given Writable stream.
Static Readonlycapture
Staticcapture
Sets or gets the default captureRejection value for all emitters.
-Staticdefault
Static Readonlyerror
This symbol shall be used to install a listener for only monitoring 'error'
-events. Listeners installed using this symbol are called before the regular
-'error' listeners are called.
Installing a listener using this symbol does not change the behavior once an
-'error' event is emitted, therefore the process will still crash if no
-regular 'error' listener is installed.
Methods
[async
[async
Optional[capture
Optional_construct
_destroy
_final
_flush
_read
_transform
_write
Optional_writev
add
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- drain -
- end -
- error -
- finish -
- pause -
- pipe -
- readable -
- resume -
- unpipe -
Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- add
Listener(event, listener): this Event emitter -The defined events on documents including:
--
-
- close -
- data -
- end -
- error -
- pause -
- readable -
- resume -
Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
as
- as
Indexed Pairs(options?): Readable This method returns a new stream with chunks of the underlying stream paired with a counter -in the form
-[index, chunk]. The first index value is0and it increases by 1 for each chunk produced.Parameters
Optionaloptions: Pick<ArrayOptions, "signal">
Returns Readable
a stream of indexed pairs.
-
Protectedbinary
Protectedcheck
compose
cork
- cork(): void
The
-writable.cork()method forces all written data to be buffered in memory. -The buffered data will be flushed when either the uncork or end methods are called.The primary intent of
-writable.cork()is to accommodate a situation in which -several small chunks are written to the stream in rapid succession. Instead of -immediately forwarding them to the underlying destination,writable.cork()buffers all the chunks untilwritable.uncork()is called, which will pass them -all towritable._writev(), if present. This prevents a head-of-line blocking -situation where data is being buffered while waiting for the first small chunk -to be processed. However, use ofwritable.cork()without implementingwritable._writev()may have an adverse effect on throughput.See also:
-writable.uncork(),writable._writev().Returns void
destroy
- destroy(error?): this
Destroy the stream. Optionally emit an
-'error'event, and emit a'close'event (unlessemitCloseis set tofalse). After this call, the readable -stream will release any internal resources and subsequent calls topush()will be ignored.Once
-destroy()has been called any further calls will be a no-op and no -further errors except from_destroy()may be emitted as'error'.Implementors should not override this method, but instead implement
-readable._destroy().Parameters
Optionalerror: ErrorError which will be passed as payload in
-'error'event
Returns this
drop
- drop(limit, options?): Readable
This method returns a new stream with the first limit chunks dropped from the start.
-Parameters
- limit: number
the number of chunks to drop from the readable.
- Optionaloptions: Pick<ArrayOptions, "signal">
Returns Readable
a stream with limit chunks dropped from the start.
-- limit: number
emit
- emit(event): boolean
Parameters
- event: "close"
Returns boolean
- emit(event, chunk): boolean
Parameters
- event: "data"
- chunk: any
Returns boolean
- emit(event): boolean
Parameters
- event: "drain"
Returns boolean
- emit(event): boolean
Parameters
- event: "end"
Returns boolean
- emit(event, err): boolean
Parameters
- event: "error"
- err: Error
Returns boolean
- emit(event): boolean
Parameters
- event: "finish"
Returns boolean
- emit(event): boolean
Parameters
- event: "pause"
Returns boolean
- emit(event, src): boolean
Parameters
- event: "pipe"
- src: Readable
Returns boolean
- emit(event): boolean
Parameters
- event: "readable"
Returns boolean
- emit(event): boolean
Parameters
- event: "resume"
Returns boolean
- emit(event, src): boolean
Parameters
- event: "unpipe"
- src: Readable
Returns boolean
- emit(event, ...args): boolean
Parameters
- event: string | symbol
Rest...args: any[]
Returns boolean
end
- end(cb?): this
Calling the
-writable.end()method signals that no more data will be written -to theWritable. The optionalchunkandencodingarguments allow one -final additional chunk of data to be written immediately before closing the -stream.Calling the write method after calling end will raise an error.
-
- -// Write 'hello, ' and then end with 'world!'.
const fs = require('fs');
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed! -Parameters
Optionalcb: (() => void)- (): void
Returns void
Returns this
- end(chunk, cb?): this
Calling the
-writable.end()method signals that no more data will be written -to theWritable. The optionalchunkandencodingarguments allow one -final additional chunk of data to be written immediately before closing the -stream.Calling the write method after calling end will raise an error.
-
- -// Write 'hello, ' and then end with 'world!'.
const fs = require('fs');
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed! -Parameters
- chunk: any
Optional data to write. For streams not operating in object mode,
-chunkmust be a string,BufferorUint8Array. For object mode streams,chunkmay be any -JavaScript value other thannull. Optionalcb: (() => void)- (): void
Returns void
Returns this
- chunk: any
- end(chunk, encoding?, cb?): this
Calling the
-writable.end()method signals that no more data will be written -to theWritable. The optionalchunkandencodingarguments allow one -final additional chunk of data to be written immediately before closing the -stream.Calling the write method after calling end will raise an error.
-
- -// Write 'hello, ' and then end with 'world!'.
const fs = require('fs');
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed! -Parameters
- chunk: any
Optional data to write. For streams not operating in object mode,
-chunkmust be a string,BufferorUint8Array. For object mode streams,chunkmay be any -JavaScript value other thannull. Optionalencoding: BufferEncodingThe encoding if
-chunkis a stringOptionalcb: (() => void)- (): void
Returns void
Returns this
- chunk: any
event
- event
Names(): (string | symbol)[] Returns an array listing the events for which the emitter has registered -listeners. The values in the array are strings or
-Symbols.
- -const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ] -Returns (string | symbol)[]
every
- every(fn, options?): Promise<boolean>
This method is similar to
-Array.prototype.everyand calls fn on each chunk in the stream -to check if all awaited return values are truthy value for fn. Once an fn call on a chunk -awaited return value is falsy, the stream is destroyed and the promise is fulfilled withfalse. -If all of the fn calls on the chunks return a truthy value, the promise is fulfilled withtrue.Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
a function to call on each chunk of the stream. Async or not.
-- (data, options?): boolean | Promise<boolean>
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns boolean | Promise<boolean>
Optionaloptions: ArrayOptions
Returns Promise<boolean>
a promise evaluating to
-trueif fn returned a truthy value for every one of the chunks.- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
filter
- filter(fn, options?): Readable
This method allows filtering the stream. For each chunk in the stream the fn function will be called -and if it returns a truthy value, the chunk will be passed to the result stream. -If the fn function returns a promise - that promise will be
-awaited.Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
a function to filter chunks from the stream. Async or not.
-- (data, options?): boolean | Promise<boolean>
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns boolean | Promise<boolean>
Optionaloptions: ArrayOptions
Returns Readable
a stream filtered with the predicate fn.
-- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
find
- find<T>(fn, options?): Promise<undefined | T>
This method is similar to
-Array.prototype.findand calls fn on each chunk in the stream -to find a chunk with a truthy value for fn. Once an fn call's awaited return value is truthy, -the stream is destroyed and the promise is fulfilled with value for which fn returned a truthy value. -If all of the fn calls on the chunks return a falsy value, the promise is fulfilled withundefined.Type Parameters
Parameters
Returns Promise<undefined | T>
a promise evaluating to the first chunk for which fn evaluated with a truthy value, -or
-undefinedif no element was found.- find(fn, options?): Promise<any>
Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
- (data, options?): boolean | Promise<boolean>
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns boolean | Promise<boolean>
Optionaloptions: ArrayOptions
Returns Promise<any>
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
flat
- flat
Map(fn, options?): Readable This method returns a new stream by applying the given callback to each chunk of the stream -and then flattening the result.
-It is possible to return a stream or another iterable or async iterable from fn and the result streams -will be merged (flattened) into the returned stream.
-Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => any)
a function to map over every chunk in the stream. May be async. May be a stream or generator.
-- (data, options?): any
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns any
Optionaloptions: ArrayOptions
Returns Readable
a stream flat-mapped with the function fn.
-- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => any)
for
- for
Each(fn, options?): Promise<void> This method allows iterating a stream. For each chunk in the stream the fn function will be called. -If the fn function returns a promise - that promise will be
-awaited.This method is different from
-for await...ofloops in that it can optionally process chunks concurrently. -In addition, aforEachiteration can only be stopped by having passed asignaloption -and aborting the related AbortController whilefor await...ofcan be stopped withbreakorreturn. -In either case the stream will be destroyed.This method is different from listening to the
-'data'event in that it uses thereadableevent -in the underlying machinary and can limit the number of concurrent fn calls.Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>)
a function to call on each chunk of the stream. Async or not.
-- (data, options?): void | Promise<void>
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns void | Promise<void>
Optionaloptions: ArrayOptions
Returns Promise<void>
a promise for when the stream has finished.
-- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>)
get
- get
Max Listeners(): number Returns the current max listener value for the
-EventEmitterwhich is either -set byemitter.setMaxListeners(n)or defaults to defaultMaxListeners.Returns number
is
- is
Paused(): boolean The
-readable.isPaused()method returns the current operating state of theReadable. This is used primarily by the mechanism that underlies thereadable.pipe()method. In most -typical cases, there will be no reason to -use this method directly.
- -const readable = new stream.Readable();
readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false -Returns boolean
iterator
- iterator(options?): AsyncIterableIterator<any>
The iterator created by this method gives users the option to cancel the destruction -of the stream if the
-for await...ofloop is exited byreturn,break, orthrow, -or if the iterator should destroy the stream if the stream emitted an error during iteration.Parameters
Optionaloptions: {
destroyOnReturn?: boolean;
}OptionaldestroyOn Return?: boolean When set to
-false, callingreturnon the async iterator, -or exiting afor await...ofiteration using abreak,return, orthrowwill not destroy the stream. -Default:true.
Returns AsyncIterableIterator<any>
listener
- listener
Count(eventName, listener?): number Returns the number of listeners listening to the event named
-eventName.If
-listeneris provided, it will return how many times the listener -is found in the list of the listeners of the event.Parameters
- eventName: string | symbol
The name of the event being listened for
- Optionallistener: FunctionThe event handler function
-
Returns number
- eventName: string | symbol
listeners
- listeners(eventName): Function[]
Returns a copy of the array of listeners for the event named
-eventName.
- -server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ] -Parameters
- eventName: string | symbol
Returns Function[]
map
- map(fn, options?): Readable
This method allows mapping over the stream. The fn function will be called for every chunk in the stream. -If the fn function returns a promise - that promise will be
-awaited before being passed to the result stream.Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => any)
a function to map over every chunk in the stream. Async or not.
-- (data, options?): any
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns any
Optionaloptions: ArrayOptions
Returns Readable
a stream mapped with the function fn.
-- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => any)
Protectedobject
off
on
- on(event, listener): this
Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- on(event, listener): this
Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- on(event, listener): this
Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
once
- once(event, listener): this
Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- once(event, listener): this
Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- once(event, listener): this
Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
pause
- pause(): this
The
-readable.pause()method will cause a stream in flowing mode to stop -emitting'data'events, switching out of flowing mode. Any data that -becomes available will remain in the internal buffer.
- -const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
console.log(`Received ${chunk.length} bytes of data.`);
readable.pause();
console.log('There will be no additional data for 1 second.');
setTimeout(() => {
console.log('Now data will start flowing again.');
readable.resume();
}, 1000);
}); -The
-readable.pause()method has no effect if there is a'readable'event listener.Returns this
pipe
prepend
- prepend
Listener(event, listener): this Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- prepend
Listener(event, listener): this Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
prepend
- prepend
Once Listener(event, listener): this Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- prepend
Once Listener(event, listener): this Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
push
raw
- raw
Listeners(eventName): Function[] Returns a copy of the array of listeners for the event named
-eventName, -including any wrappers (such as those created by.once()).
- -const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log'); -Parameters
- eventName: string | symbol
Returns Function[]
read
- read(size?): any
The
-readable.read()method reads data out of the internal buffer and -returns it. If no data is available to be read,nullis returned. By default, -the data is returned as aBufferobject unless an encoding has been -specified using thereadable.setEncoding()method or the stream is operating -in object mode.The optional
-sizeargument specifies a specific number of bytes to read. Ifsizebytes are not available to be read,nullwill be returned _unless_the stream has ended, in which -case all of the data remaining in the internal -buffer will be returned.If the
-sizeargument is not specified, all of the data contained in the -internal buffer will be returned.The
-sizeargument must be less than or equal to 1 GiB.The
-readable.read()method should only be called onReadablestreams -operating in paused mode. In flowing mode,readable.read()is called -automatically until the internal buffer is fully drained.
- -const readable = getReadableStreamSomehow();
// 'readable' may be triggered multiple times as data is buffered in
readable.on('readable', () => {
let chunk;
console.log('Stream is readable (new data received in buffer)');
// Use a loop to make sure we read all currently available data
while (null !== (chunk = readable.read())) {
console.log(`Read ${chunk.length} bytes of data...`);
}
});
// 'end' will be triggered once when there is no more data available
readable.on('end', () => {
console.log('Reached end of stream.');
}); -Each call to
-readable.read()returns a chunk of data, ornull. The chunks -are not concatenated. Awhileloop is necessary to consume all data -currently in the buffer. When reading a large file.read()may returnnull, -having consumed all buffered content so far, but there is still more data to -come not yet buffered. In this case a new'readable'event will be emitted -when there is more data in the buffer. Finally the'end'event will be -emitted when there is no more data to come.Therefore to read a file's whole contents from a
-readable, it is necessary -to collect chunks across multiple'readable'events:
- -const chunks = [];
readable.on('readable', () => {
let chunk;
while (null !== (chunk = readable.read())) {
chunks.push(chunk);
}
});
readable.on('end', () => {
const content = chunks.join('');
}); -A
-Readablestream in object mode will always return a single item from -a call toreadable.read(size), regardless of the value of thesizeargument.If the
-readable.read()method returns a chunk of data, a'data'event will -also be emitted.Calling read after the
-'end'event has -been emitted will returnnull. No runtime error will be raised.Parameters
Optionalsize: numberOptional argument to specify how much data to read.
-
Returns any
reduce
- reduce<T>(fn, initial?, options?): Promise<T>
This method calls fn on each chunk of the stream in order, passing it the result from the calculation -on the previous element. It returns a promise for the final value of the reduction.
-If no initial value is supplied the first chunk of the stream is used as the initial value. -If the stream is empty, the promise is rejected with a
-TypeErrorwith theERR_INVALID_ARGScode property.The reducer function iterates the stream element-by-element which means that there is no concurrency parameter -or parallelism. To perform a reduce concurrently, you can extract the async function to
-readable.mapmethod.Type Parameters
Parameters
- fn: ((previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T)
a reducer function to call over every chunk in the stream. Async or not.
- Optionalinitial: undefinedthe initial value to use in the reduction.
-Optionaloptions: Pick<ArrayOptions, "signal">
Returns Promise<T>
a promise for the final value of the reduction.
-- fn: ((previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T)
- reduce<T>(fn, initial, options?): Promise<T>
Type Parameters
Parameters
Returns Promise<T>
remove
- remove
All Listeners(event?): this Removes all listeners, or those of the specified
-eventName.It is bad practice to remove listeners added elsewhere in the code, -particularly when the
-EventEmitterinstance was created by some other -component or module (e.g. sockets or file streams).Returns a reference to the
-EventEmitter, so that calls can be chained.Parameters
Optionalevent: string | symbol
Returns this
remove
- remove
Listener(event, listener): this Parameters
- event: "close"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "data"
- listener: ((chunk: any) => void)
- (chunk): void
Parameters
- chunk: any
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "drain"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "end"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "error"
- listener: ((err: Error) => void)
- (err): void
Parameters
- err: Error
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "finish"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "pause"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "pipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "readable"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "resume"
- listener: (() => void)
- (): void
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: "unpipe"
- listener: ((src: Readable) => void)
- (src): void
Parameters
- src: Readable
Returns void
Returns this
- remove
Listener(event, listener): this Parameters
- event: string | symbol
- listener: ((...args: any[]) => void)
- (...args): void
Parameters
Rest...args: any[]
Returns void
Returns this
resume
- resume(): this
The
-readable.resume()method causes an explicitly pausedReadablestream to -resume emitting'data'events, switching the stream into flowing mode.The
-readable.resume()method can be used to fully consume the data from a -stream without actually processing any of that data:
- -getReadableStreamSomehow()
.resume()
.on('end', () => {
console.log('Reached the end, but did not read anything.');
}); -The
-readable.resume()method has no effect if there is a'readable'event listener.Returns this
set
set
- set
Encoding(encoding): this The
-readable.setEncoding()method sets the character encoding for -data read from theReadablestream.By default, no encoding is assigned and stream data will be returned as
-Bufferobjects. Setting an encoding causes the stream data -to be returned as strings of the specified encoding rather than asBufferobjects. For instance, callingreadable.setEncoding('utf8')will cause the -output data to be interpreted as UTF-8 data, and passed as strings. Callingreadable.setEncoding('hex')will cause the data to be encoded in hexadecimal -string format.The
-Readablestream will properly handle multi-byte characters delivered -through the stream that would otherwise become improperly decoded if simply -pulled from the stream asBufferobjects.
- -const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
assert.equal(typeof chunk, 'string');
console.log('Got %d characters of string data:', chunk.length);
}); -Parameters
- encoding: BufferEncoding
The encoding to use.
-
Returns this
- encoding: BufferEncoding
set
- set
Max Listeners(n): this By default
-EventEmitters will print a warning if more than10listeners are -added for a particular event. This is a useful default that helps finding -memory leaks. Theemitter.setMaxListeners()method allows the limit to be -modified for this specificEventEmitterinstance. The value can be set toInfinity(or0) to indicate an unlimited number of listeners.Returns a reference to the
-EventEmitter, so that calls can be chained.Parameters
- n: number
Returns this
some
- some(fn, options?): Promise<boolean>
This method is similar to
-Array.prototype.someand calls fn on each chunk in the stream -until the awaited return value istrue(or any truthy value). Once an fn call on a chunk -awaited return value is truthy, the stream is destroyed and the promise is fulfilled withtrue. -If none of the fn calls on the chunks return a truthy value, the promise is fulfilled withfalse.Parameters
- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
a function to call on each chunk of the stream. Async or not.
-- (data, options?): boolean | Promise<boolean>
Parameters
- data: any
Optionaloptions: Pick<ArrayOptions, "signal">
Returns boolean | Promise<boolean>
Optionaloptions: ArrayOptions
Returns Promise<boolean>
a promise evaluating to
-trueif fn returned a truthy value for at least one of the chunks.- fn: ((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>)
take
to
- to
Array(options?): Promise<any[]> This method allows easily obtaining the contents of a stream.
-As this method reads the entire stream into memory, it negates the benefits of streams. It's intended -for interoperability and convenience, not as the primary way to consume streams.
-Parameters
Optionaloptions: Pick<ArrayOptions, "signal">
Returns Promise<any[]>
a promise containing an array with the contents of the stream.
-
uncork
- uncork(): void
The
-writable.uncork()method flushes all data buffered since cork was called.When using
-writable.cork()andwritable.uncork()to manage the buffering -of writes to a stream, defer calls towritable.uncork()usingprocess.nextTick(). Doing so allows batching of allwritable.write()calls that occur within a given Node.js event -loop phase.
- -stream.cork();
stream.write('some ');
stream.write('data ');
process.nextTick(() => stream.uncork()); -If the
-writable.cork()method is called multiple times on a stream, the -same number of calls towritable.uncork()must be called to flush the buffered -data.
- -stream.cork();
stream.write('some ');
stream.cork();
stream.write('data ');
process.nextTick(() => {
stream.uncork();
// The data will not be flushed until uncork() is called a second time.
stream.uncork();
}); -See also:
-writable.cork().Returns void
unpipe
- unpipe(destination?): this
The
-readable.unpipe()method detaches aWritablestream previously attached -using the pipe method.If the
-destinationis not specified, then all pipes are detached.If the
-destinationis specified, but no pipe is set up for it, then -the method does nothing.
- -const fs = require('fs');
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
console.log('Stop writing to file.txt.');
readable.unpipe(writable);
console.log('Manually close the file stream.');
writable.end();
}, 1000); -Parameters
Optionaldestination: WritableStreamOptional specific stream to unpipe
-
Returns this
unshift
- unshift(chunk, encoding?): void
Passing
-chunkasnullsignals the end of the stream (EOF) and behaves the -same asreadable.push(null), after which no more data can be written. The EOF -signal is put at the end of the buffer and any buffered data will still be -flushed.The
-readable.unshift()method pushes a chunk of data back into the internal -buffer. This is useful in certain situations where a stream is being consumed by -code that needs to "un-consume" some amount of data that it has optimistically -pulled out of the source, so that the data can be passed on to some other party.The
-stream.unshift(chunk)method cannot be called after the'end'event -has been emitted or a runtime error will be thrown.Developers using
-stream.unshift()often should consider switching to -use of aTransformstream instead. See theAPI for stream implementerssection for more information.
- -// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
const { StringDecoder } = require('string_decoder');
function parseHeader(stream, callback) {
stream.on('error', callback);
stream.on('readable', onReadable);
const decoder = new StringDecoder('utf8');
let header = '';
function onReadable() {
let chunk;
while (null !== (chunk = stream.read())) {
const str = decoder.write(chunk);
if (str.includes('\n\n')) {
// Found the header boundary.
const split = str.split(/\n\n/);
header += split.shift();
const remaining = split.join('\n\n');
const buf = Buffer.from(remaining, 'utf8');
stream.removeListener('error', callback);
// Remove the 'readable' listener before unshifting.
stream.removeListener('readable', onReadable);
if (buf.length)
stream.unshift(buf);
// Now the body of the message can be read from the stream.
callback(null, header, stream);
return;
}
// Still reading the header.
header += str;
}
}
} -Unlike push,
-stream.unshift(chunk)will not -end the reading process by resetting the internal reading state of the stream. -This can cause unexpected results ifreadable.unshift()is called during a -read (i.e. from within a _read implementation on a -custom stream). Following the call toreadable.unshift()with an immediate push will reset the reading state appropriately, -however it is best to simply avoid callingreadable.unshift()while in the -process of performing a read.Parameters
- chunk: any
Chunk of data to unshift onto the read queue. For streams not operating in object mode,
-chunkmust be a string,Buffer,Uint8Arrayornull. For object mode -streams,chunkmay be any JavaScript value. Optionalencoding: BufferEncodingEncoding of string chunks. Must be a valid
-Bufferencoding, such as'utf8'or'ascii'.
Returns void
- chunk: any
wrap
- wrap(stream): this
Prior to Node.js 0.10, streams did not implement the entire
-streammodule API -as it is currently defined. (SeeCompatibilityfor more information.)When using an older Node.js library that emits
-'data'events and has a pause method that is advisory only, thereadable.wrap()method can be used to create aReadable-stream that uses -the old stream as its data source.It will rarely be necessary to use
-readable.wrap()but the method has been -provided as a convenience for interacting with older Node.js applications and -libraries.
- -const { OldReader } = require('./old-api-module.js');
const { Readable } = require('stream');
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);
myReader.on('readable', () => {
myReader.read(); // etc.
}); -Parameters
- stream: ReadableStream
An "old style" readable stream
-
Returns this
- stream: ReadableStream
write
- write(chunk, encoding?, cb?): boolean
The
-writable.write()method writes some data to the stream, and calls the -suppliedcallbackonce the data has been fully handled. If an error -occurs, thecallbackwill be called with the error as its -first argument. Thecallbackis called asynchronously and before'error'is -emitted.The return value is
-trueif the internal buffer is less than thehighWaterMarkconfigured when the stream was created after admittingchunk. -Iffalseis returned, further attempts to write data to the stream should -stop until the'drain'event is emitted.While a stream is not draining, calls to
-write()will bufferchunk, and -return false. Once all currently buffered chunks are drained (accepted for -delivery by the operating system), the'drain'event will be emitted. -Oncewrite()returns false, do not write more chunks -until the'drain'event is emitted. While callingwrite()on a stream that -is not draining is allowed, Node.js will buffer all written chunks until -maximum memory usage occurs, at which point it will abort unconditionally. -Even before it aborts, high memory usage will cause poor garbage collector -performance and high RSS (which is not typically released back to the system, -even after the memory is no longer required). Since TCP sockets may never -drain if the remote peer does not read the data, writing a socket that is -not draining may lead to a remotely exploitable vulnerability.Writing data while the stream is not draining is particularly -problematic for a
-Transform, because theTransformstreams are paused -by default until they are piped or a'data'or'readable'event handler -is added.If the data to be written can be generated or fetched on demand, it is -recommended to encapsulate the logic into a
-Readableand use pipe. However, if callingwrite()is preferred, it is -possible to respect backpressure and avoid memory issues using the'drain'event:
- -function write(data, cb) {
if (!stream.write(data)) {
stream.once('drain', cb);
} else {
process.nextTick(cb);
}
}
// Wait for cb to be called before doing any other write.
write('hello', () => {
console.log('Write completed, do more writes now.');
}); -A
-Writablestream in object mode will always ignore theencodingargument.Parameters
- chunk: any
Optional data to write. For streams not operating in object mode,
-chunkmust be a string,BufferorUint8Array. For object mode streams,chunkmay be any -JavaScript value other thannull. Optionalencoding: BufferEncodingThe encoding, if
-chunkis a string.Optionalcb: ((error: undefined | null | Error) => void)- (error): void
Parameters
- error: undefined | null | Error
Returns void
Returns boolean
-falseif the stream wishes for the calling code to wait for the'drain'event to be emitted before continuing to write additional data; otherwisetrue.- chunk: any
- write(chunk, cb?): boolean
The
-writable.write()method writes some data to the stream, and calls the -suppliedcallbackonce the data has been fully handled. If an error -occurs, thecallbackwill be called with the error as its -first argument. Thecallbackis called asynchronously and before'error'is -emitted.The return value is
-trueif the internal buffer is less than thehighWaterMarkconfigured when the stream was created after admittingchunk. -Iffalseis returned, further attempts to write data to the stream should -stop until the'drain'event is emitted.While a stream is not draining, calls to
-write()will bufferchunk, and -return false. Once all currently buffered chunks are drained (accepted for -delivery by the operating system), the'drain'event will be emitted. -Oncewrite()returns false, do not write more chunks -until the'drain'event is emitted. While callingwrite()on a stream that -is not draining is allowed, Node.js will buffer all written chunks until -maximum memory usage occurs, at which point it will abort unconditionally. -Even before it aborts, high memory usage will cause poor garbage collector -performance and high RSS (which is not typically released back to the system, -even after the memory is no longer required). Since TCP sockets may never -drain if the remote peer does not read the data, writing a socket that is -not draining may lead to a remotely exploitable vulnerability.Writing data while the stream is not draining is particularly -problematic for a
-Transform, because theTransformstreams are paused -by default until they are piped or a'data'or'readable'event handler -is added.If the data to be written can be generated or fetched on demand, it is -recommended to encapsulate the logic into a
-Readableand use pipe. However, if callingwrite()is preferred, it is -possible to respect backpressure and avoid memory issues using the'drain'event:
- -function write(data, cb) {
if (!stream.write(data)) {
stream.once('drain', cb);
} else {
process.nextTick(cb);
}
}
// Wait for cb to be called before doing any other write.
write('hello', () => {
console.log('Write completed, do more writes now.');
}); -A
-Writablestream in object mode will always ignore theencodingargument.Parameters
- chunk: any
Optional data to write. For streams not operating in object mode,
-chunkmust be a string,BufferorUint8Array. For object mode streams,chunkmay be any -JavaScript value other thannull. Optionalcb: ((error: undefined | null | Error) => void)- (error): void
Parameters
- error: undefined | null | Error
Returns void
Returns boolean
-falseif the stream wishes for the calling code to wait for the'drain'event to be emitted before continuing to write additional data; otherwisetrue.- chunk: any
Staticadd
- add
Abort Listener(signal, resource): Disposable ExperimentalListens once to the
-abortevent on the providedsignal.Listening to the
-abortevent on abort signals is unsafe and may -lead to resource leaks since another third party with the signal can -calle.stopImmediatePropagation(). Unfortunately Node.js cannot change -this since it would violate the web standard. Additionally, the original -API makes it easy to forget to remove listeners.This API allows safely using
-AbortSignals in Node.js APIs by solving these -two issues by listening to the event such thatstopImmediatePropagationdoes -not prevent the listener from running.Returns a disposable so that it may be unsubscribed from more easily.
-
- -import { addAbortListener } from 'node:events';
function example(signal) {
let disposable;
try {
signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
disposable = addAbortListener(signal, (e) => {
// Do something when signal is aborted.
});
} finally {
disposable?.[Symbol.dispose]();
}
} -Parameters
- signal: AbortSignal
- resource: ((event: Event) => void)
- (event): void
Parameters
- event: Event
Returns void
Returns Disposable
Disposable that removes the
-abortlistener.
Staticfrom
- from(src): Duplex
A utility method for creating duplex streams.
--
-
Streamconverts writable stream into writableDuplexand readable stream -toDuplex.
-Blobconverts into readableDuplex.
-stringconverts into readableDuplex.
-ArrayBufferconverts into readableDuplex.
-AsyncIterableconverts into a readableDuplex. Cannot yieldnull.
-AsyncGeneratorFunctionconverts into a readable/writable transform -Duplex. Must take a sourceAsyncIterableas first parameter. Cannot yield -null.
-AsyncFunctionconverts into a writableDuplex. Must return -eithernullorundefined
-Object ({ writable, readable })convertsreadableand -writableintoStreamand then combines them intoDuplexwhere the -Duplexwill write to thewritableand read from thereadable.
-Promiseconverts into readableDuplex. Valuenullis ignored.
-
Parameters
- src:
| string
| Object
| Stream
| Promise<any>
| Iterable<any>
| AsyncIterable<any>
| ArrayBuffer
| Blob
| AsyncGeneratorFunction
Returns Duplex
Staticfrom
Staticget
- get
Event Listeners(emitter, name): Function[] Returns a copy of the array of listeners for the event named
-eventName.For
-EventEmitters this behaves exactly the same as calling.listenerson -the emitter.For
-EventTargets this is the only way to get the event listeners for the -event target. This is useful for debugging and diagnostic purposes.
- -const { getEventListeners, EventEmitter } = require('events');
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
getEventListeners(ee, 'foo'); // [listener]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
getEventListeners(et, 'foo'); // [listener]
} -Parameters
- emitter: EventEmitter | _DOMEventTarget
- name: string | symbol
Returns Function[]
Staticget
- get
Max Listeners(emitter): number Returns the currently set max amount of listeners.
-For
-EventEmitters this behaves exactly the same as calling.getMaxListenerson -the emitter.For
-EventTargets this is the only way to get the max event listeners for the -event target. If the number of event handlers on a single EventTarget exceeds -the max set, the EventTarget will print a warning.
- -import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
console.log(getMaxListeners(ee)); // 10
setMaxListeners(11, ee);
console.log(getMaxListeners(ee)); // 11
}
{
const et = new EventTarget();
console.log(getMaxListeners(et)); // 10
setMaxListeners(11, et);
console.log(getMaxListeners(et)); // 11
} -Parameters
- emitter: EventEmitter | _DOMEventTarget
Returns number
Staticis
Staticlistener
- listener
Count(emitter, eventName): number A class method that returns the number of listeners for the given
-eventNameregistered on the givenemitter.
- -const { EventEmitter, listenerCount } = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2 -Parameters
- emitter: EventEmitter
The emitter to query
- - eventName: string | symbol
The event name
-
Returns number
- emitter: EventEmitter
Staticon
- on(emitter, eventName, options?): AsyncIterableIterator<any>
- -const { on, EventEmitter } = require('events');
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})(); -Returns an
-AsyncIteratorthat iterateseventNameevents. It will throw -if theEventEmitteremits'error'. It removes all listeners when -exiting the loop. Thevaluereturned by each iteration is an array -composed of the emitted event arguments.An
-AbortSignalcan be used to cancel waiting on events:
- -const { on, EventEmitter } = require('events');
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort()); -Parameters
- emitter: EventEmitter
- eventName: string
The name of the event being listened for
- Optionaloptions: StaticEventEmitterOptions
Returns AsyncIterableIterator<any>
that iterates
-eventNameevents emitted by theemitter
Staticonce
- once(emitter, eventName, options?): Promise<any[]>
Creates a
-Promisethat is fulfilled when theEventEmitteremits the given -event or that is rejected if theEventEmitteremits'error'while waiting. -ThePromisewill resolve with an array of all the arguments emitted to the -given event.This method is intentionally generic and works with the web platform EventTarget interface, which has no special
-'error'event -semantics and does not listen to the'error'event.
- -const { once, EventEmitter } = require('events');
async function run() {
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.log('error happened', err);
}
}
run(); -The special handling of the
-'error'event is only used whenevents.once()is used to wait for another event. Ifevents.once()is used to wait for the -'error'event itself, then it is treated as any other kind of event without -special handling:
- -const { EventEmitter, once } = require('events');
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.log('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom -An
-AbortSignalcan be used to cancel waiting for the event:
- -const { EventEmitter, once } = require('events');
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled! -Parameters
- emitter: _NodeEventTarget
- eventName: string | symbol
Optionaloptions: StaticEventEmitterOptions
Returns Promise<any[]>
- once(emitter, eventName, options?): Promise<any[]>
Parameters
- emitter: _DOMEventTarget
- eventName: string
Optionaloptions: StaticEventEmitterOptions
Returns Promise<any[]>
Staticset
- set
Max Listeners(n?, ...eventTargets): void
- -const {
setMaxListeners,
EventEmitter
} = require('events');
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter); -Parameters
Optionaln: numberA non-negative number. The maximum number of listeners per
-EventTargetevent.Rest...eventTargets: (EventEmitter | _DOMEventTarget)[]
Returns void
Staticto
Class SlugParser
Converts the contents of the slug header to metadata.
-Hierarchy (view full)
- MetadataParser
- SlugParser
Index
Constructors
constructor
- new
Slug Parser(): SlugParser Returns SlugParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that could potentially be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input that needs to be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
metadata: RepresentationMetadata;
request: HttpRequest;
}Input data that will be handled if it can be handled.
-metadata: RepresentationMetadata
request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class SparqlDataAccessor
Stores all data and metadata of resources in a SPARQL backend. -Communication is done by sending SPARQL queries. -Queries are constructed in such a way to keep everything consistent, -such as updating containment triples and deleting old data when it is overwritten.
-Since metadata is hidden, no containment triples are stored for metadata files.
-All input container metadata is stored in its metadata identifier. -The containment triples are stored in the graph corresponding to the actual identifier -so those don't get overwritten.
-Implements
Index
Constructors
constructor
- new
Sparql Data Accessor(endpoint, identifierStrategy): SparqlDataAccessor Parameters
- endpoint: string
- identifierStrategy: IdentifierStrategy
Returns SparqlDataAccessor
Methods
can
- can
Handle(representation): Promise<void> Only Quad data streams are supported.
-Parameters
- representation: Representation
Returns Promise<void>
delete
- delete
Resource(identifier): Promise<void> Removes all graph data relevant to the given identifier.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<void>
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Returns all triples stored for the corresponding identifier. -Note that this will not throw a 404 if no results were found.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<Guarded<Readable>>
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata for the corresponding identifier. -Will throw 404 if no metadata was found.
-Parameters
- identifier: ResourceIdentifier
Returns Promise<RepresentationMetadata>
write
- write
Container(identifier, metadata): Promise<void> Writes the given metadata for the container.
-Parameters
- identifier: ResourceIdentifier
- metadata: RepresentationMetadata
Returns Promise<void>
write
- write
Document(identifier, data, metadata): Promise<void> Reads the given data stream and stores it together with the metadata.
-Parameters
- identifier: ResourceIdentifier
- data: Guarded<Readable>
- metadata: RepresentationMetadata
Returns Promise<void>
write
- write
Metadata(identifier, metadata): Promise<void> Reads the metadata and stores it.
-Parameters
- identifier: ResourceIdentifier
- metadata: RepresentationMetadata
Returns Promise<void>
Class SparqlUpdateBodyParser
BodyParser that supports application/sparql-update content.
-Will convert the incoming update string to algebra in a SparqlUpdatePatch.
Hierarchy (view full)
- BodyParser
- SparqlUpdateBodyParser
Index
Constructors
constructor
- new
Sparql Update Body Parser(): SparqlUpdateBodyParser Returns SparqlUpdateBodyParser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: BodyParserArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
handle
- handle(input): Promise<SparqlUpdatePatch>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: BodyParserArgs
Input that needs to be handled.
-
Returns Promise<SparqlUpdatePatch>
A promise resolving when handling is finished.
-- input: BodyParserArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: BodyParserArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: BodyParserArgs
Class SparqlUpdateModesExtractor
Generates permissions for a SPARQL DELETE/INSERT body. -Updates with only an INSERT can be done with just append permissions, -while DELETEs require write permissions as well.
-Hierarchy (view full)
- ModesExtractor
- SparqlUpdateModesExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Sparql Update Modes Extractor(resourceSet): SparqlUpdateModesExtractor Certain permissions depend on the existence of the target resource. -The provided ResourceSet will be used for that.
-Parameters
- resourceSet: ResourceSet
ResourceSet that can verify the target resource existence.
-
Returns SparqlUpdateModesExtractor
- resourceSet: ResourceSet
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Operation
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
handle
- handle(input): Promise<AccessMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: Operation
Input that needs to be handled.
-
Returns Promise<AccessMap>
A promise resolving when handling is finished.
-- input: Operation
handle
- handle
Safe(input): Promise<AccessMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Operation
Input data that will be handled if it can be handled.
-
Returns Promise<AccessMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Operation
Class SparqlUpdatePatcher
Supports application/sparql-update PATCH requests on RDF resources.
-Only DELETE/INSERT updates without variables are supported.
-Hierarchy (view full)
- RepresentationPatcher<RdfDatasetRepresentation>
- SparqlUpdatePatcher
Index
Constructors
constructor
- new
Sparql Update Patcher(): SparqlUpdatePatcher Returns SparqlUpdatePatcher
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle(input): Promise<RdfDatasetRepresentation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input that needs to be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving when handling is finished.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
handle
- handle
Safe(input): Promise<RdfDatasetRepresentation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Input data that will be handled if it can be handled.
-
Returns Promise<RdfDatasetRepresentation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationPatcherInput<RdfDatasetRepresentation>
Class StateHandlerAbstract
Handles the state feature of notifications.
-Every implementation of a specific notification channel type should make sure an instance of this class
-gets called when a state notification can be sent out.
Implementations of this class should handle all channels and filter out those that need a state notification.
Hierarchy (view full)
- AsyncHandler<{
channel: NotificationChannel;
}>- StateHandler
Index
Constructors
Methods
Constructors
constructor
- new
State Handler(): StateHandler Returns StateHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
channel: NotificationChannel;
}Input that could potentially be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
channel: NotificationChannel;
}Input that needs to be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
channel: NotificationChannel;
}Input data that will be handled if it can be handled.
-channel: NotificationChannel
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class StateNotificationGenerator
Determines the most relevant activity for a Notification in case none was provided.
-This is relevant for the state feature where a notification channel needs to know the current state of a resource.
Hierarchy (view full)
- NotificationGenerator
- StateNotificationGenerator
Index
Constructors
Methods
Constructors
constructor
- new
State Notification Generator(source, resourceSet): StateNotificationGenerator Parameters
- source: NotificationGenerator
- resourceSet: ResourceSet
Returns StateNotificationGenerator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<Notification>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<Notification>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<Notification> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<Notification>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class StaticAssetEntry
Used to link file paths with relative URLs. -By using a separate class instead of a key/value map it is easier to replace values in Components.js.
- Index
Constructors
Properties
Constructors
constructor
- new
Static Asset Entry(relativeUrl, filePath): StaticAssetEntry Parameters
- relativeUrl: string
- filePath: string
Returns StaticAssetEntry
Class StaticAssetHandler
Handler that serves static resources on specific paths.
-Relative file paths are assumed to be relative to the current working directory.
-Relative file paths can be preceded by @css:, e.g. @css:foo/bar,
-in case they need to be relative to the module root.
-File paths ending in a slash assume the target is a folder and map all of its contents.
Hierarchy (view full)
- HttpHandler
- StaticAssetHandler
Index
Constructors
Methods
Constructors
constructor
- new
Static Asset Handler(assets, baseUrl, options?): StaticAssetHandler Creates a handler for the provided static resources.
-Parameters
- assets: StaticAssetEntry[]
A list of StaticAssetEntry.
- - baseUrl: string
The base URL of the server.
- - options: {
expires?: number;
} = {}Specific options.
-Optionalexpires?: numberCache expiration time in seconds.
-
Returns StaticAssetHandler
- assets: StaticAssetEntry[]
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: HttpHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class StaticFolderGenerator
Stores a static template folder that will be used to call the wrapped TemplatedResourcesGenerator.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Static Folder Generator(resourcesGenerator, templateFolder): StaticFolderGenerator Parameters
- resourcesGenerator: TemplatedResourcesGenerator
- templateFolder: string
Returns StaticFolderGenerator
Methods
generate
- generate(location, options): AsyncIterable<Resource>
Generates resources with the given options. -The output Iterable should be sorted so that containers always appear before their contents.
-Parameters
- location: ResourceIdentifier
Base identifier.
- - options: Dict<unknown>
Options that can be used when generating resources.
-
Returns AsyncIterable<Resource>
A map where the keys are the identifiers and the values the corresponding representations to store.
-- location: ResourceIdentifier
Class StaticHandler<T>
A handler that always resolves and always returns the stored value. -Will return undefined if no value is stored.
-The generic type extends any due to Components.js requirements.
Type Parameters
Hierarchy (view full)
- AsyncHandler<unknown, T>
Index
Constructors
Methods
Constructors
constructor
- new
Static Handler<T>(value?): StaticHandler<T> Type Parameters
Parameters
Optionalvalue: T
Returns StaticHandler<T>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: unknown
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
handle
- handle(): Promise<T>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<T>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<T> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: unknown
Input data that will be handled if it can be handled.
-
Returns Promise<T>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
Class StaticInteractionHandler
An JsonInteractionHandler that always returns the same JSON response on all requests.
-Hierarchy (view full)
- JsonInteractionHandler
- StaticInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Static Interaction Handler(response): StaticInteractionHandler Parameters
- response: Record<string, Json>
Returns StaticInteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class StaticStorageDescriber
Adds a fixed set of triples to the storage description resource, -with the resource identifier as subject.
-This can be used to add descriptions that a storage always needs to have,
-such as the <> a pim:Storage triple.
Hierarchy (view full)
- StorageDescriber
- StaticStorageDescriber
Index
Constructors
Methods
Constructors
constructor
- new
Static Storage Describer(terms): StaticStorageDescriber Parameters
- terms: Record<string, string | string[]>
Returns StaticStorageDescriber
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ResourceIdentifier
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
handle
- handle(target): Promise<Quad[]>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- target: ResourceIdentifier
Returns Promise<Quad[]>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Quad[]> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ResourceIdentifier
Input data that will be handled if it can be handled.
-
Returns Promise<Quad[]>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
Class StaticTemplateEngine<T>
Template engine that renders output based on a static template file.
-Type Parameters
Hierarchy (view full)
- TemplateEngine<T>
- StaticTemplateEngine
Index
Constructors
Methods
Constructors
constructor
- new
Static Template Engine<T>(templateEngine, template): StaticTemplateEngine<T> Creates a new StaticTemplateEngine.
-Type Parameters
Parameters
- templateEngine: AsyncHandler<TemplateEngineInput<T>, string>
The template engine that should be used for processing the template.
- - template: Template
The static template to be used.
-
Returns StaticTemplateEngine<T>
- templateEngine: AsyncHandler<TemplateEngineInput<T>, string>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
handle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class StaticThrowHandler
Utility handler that can handle all input and always throws an instance of the given error.
-Hierarchy (view full)
- AsyncHandler<unknown, never>
- StaticThrowHandler
Index
Constructors
constructor
- new
Static Throw Handler(error): StaticThrowHandler Parameters
- error: HttpError<number>
Returns StaticThrowHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: unknown
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
handle
- handle(): Promise<never>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<never>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<never> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: unknown
Input data that will be handled if it can be handled.
-
Returns Promise<never>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
Class StorageDescriberAbstract
Generates Quads that need to be added to the given storage description resource.
-Hierarchy (view full)
- AsyncHandler<ResourceIdentifier, Quad[]>
- StorageDescriber
Index
Constructors
Methods
Constructors
constructor
- new
Storage Describer(): StorageDescriber Returns StorageDescriber
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ResourceIdentifier
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
Abstracthandle
- handle(input): Promise<Quad[]>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ResourceIdentifier
Input that needs to be handled.
-
Returns Promise<Quad[]>
A promise resolving when handling is finished.
-- input: ResourceIdentifier
handle
- handle
Safe(input): Promise<Quad[]> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ResourceIdentifier
Input data that will be handled if it can be handled.
-
Returns Promise<Quad[]>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ResourceIdentifier
Class StorageDescriptionAdvertiser
Adds a link header pointing to the relevant storage description resource. -Recursively checks parent containers until a storage container is found, -and then appends the provided relative path to determine the storage description resource.
-Hierarchy (view full)
- MetadataWriter
- StorageDescriptionAdvertiser
Index
Constructors
constructor
- new
Storage Description Advertiser(storageStrategy, relativePath): StorageDescriptionAdvertiser Parameters
- storageStrategy: StorageLocationStrategy
- relativePath: string
Returns StorageDescriptionAdvertiser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: MetadataWriterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: MetadataWriterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class StorageDescriptionHandler
Generates the response for GET requests targeting a storage description resource. -The input path needs to match the relative path used to generate storage description resources -and will be used to verify if the container it is linked to is an actual storage.
-Hierarchy (view full)
- OperationHttpHandler
- StorageDescriptionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Storage Description Handler(store, path, describer): StorageDescriptionHandler Parameters
- store: ResourceStore
- path: string
- describer: StorageDescriber
Returns StorageDescriptionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Protectedget
- get
Storage Identifier(descriptionIdentifier): ResourceIdentifier Determine the identifier of the root storage based on the identifier of the root storage description resource.
-Parameters
- descriptionIdentifier: ResourceIdentifier
Returns ResourceIdentifier
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class StreamingHttp2023Emitter
Emits notifications on StreamingHTTPChannel2023 streams. -Uses the response streams found in the provided map. -The key should be the identifier of the topic resource.
-Hierarchy (view full)
- AsyncHandler<StreamingHttpEmitterInput>
- StreamingHttp2023Emitter
Index
Constructors
constructor
- new
Streaming Http2023 Emitter(streamMap): StreamingHttp2023Emitter Parameters
- streamMap: StreamingHttpMap
Returns StreamingHttp2023Emitter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: StreamingHttpEmitterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: StreamingHttpEmitterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: StreamingHttpEmitterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: StreamingHttpEmitterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: StreamingHttpEmitterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: StreamingHttpEmitterInput
Class StreamingHttpListeningActivityHandler
Listens to an ActivityEmitter and calls the stored NotificationHandlers in case of an event -for every matching notification channel found.
-Extends StaticHandler so it can be more easily injected into a Components.js configuration. -No class takes this one as input, so to make sure Components.js instantiates it, -it needs to be added somewhere where its presence has no impact, such as the list of initializers.
-Hierarchy (view full)
- StaticHandler
- StreamingHttpListeningActivityHandler
Index
Constructors
constructor
- new
Streaming Http Listening Activity Handler(emitter, streamMap, source): StreamingHttpListeningActivityHandler Parameters
- emitter: ActivityEmitter
- streamMap: StreamingHttpMap
- source: NotificationHandler
Returns StreamingHttpListeningActivityHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: unknown
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: unknown
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
Class StreamingHttpMap
A SetMultiMap linking identifiers to a set of Streaming HTTP streams. -An extension of WrappedSetMultiMap to make sure Components.js allows us to create this in the config, -as WrappedSetMultiMap has a constructor not supported.
-Hierarchy (view full)
- WrappedSetMultiMap<string, PassThrough>
- StreamingHttpMap
Implements
Index
Constructors
constructor
- new
Streaming Http Map(mapConstructor?, iterable?): StreamingHttpMap Parameters
- mapConstructor: (new () => Map<string, Set<PassThrough>>) = Map
Will be used to instantiate the internal Map.
-- new (): Map<string, Set<PassThrough>>
Returns Map<string, Set<PassThrough>>
Optionaliterable: Iterable<readonly [string, PassThrough | ReadonlySet<PassThrough>]>Entries to add to the map.
-
Returns StreamingHttpMap
- mapConstructor: (new () => Map<string, Set<PassThrough>>) = Map
Methods
[iterator]
add
as
clear
delete
delete
distinct
entries
entry
for
- for
Each(callbackfn, thisArg?): void Loops over all key/value bindings.
-Parameters
- callbackfn: ((value: PassThrough, key: string, map: SetMultiMap<string, PassThrough>) => void)
- (value, key, map): void
Parameters
- value: PassThrough
- key: string
- map: SetMultiMap<string, PassThrough>
Returns void
OptionalthisArg: unknown
Returns void
- callbackfn: ((value: PassThrough, key: string, map: SetMultiMap<string, PassThrough>) => void)
get
has
has
keys
set
value
values
Class StreamingHttpMetadataWriter
A MetadataWriter that adds a link to the receiveFrom endpoint -of the corresponding Streaming HTTP notifications channel
-Hierarchy (view full)
- MetadataWriter
- StreamingHttpMetadataWriter
Index
Constructors
constructor
- new
Streaming Http Metadata Writer(baseUrl, pathPrefix): StreamingHttpMetadataWriter Parameters
- baseUrl: string
- pathPrefix: string
Returns StreamingHttpMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class StreamingHttpRequestHandler
Handles request to Streaming HTTP receiveFrom endopints. -All allowed requests are stored in the StreamingHttpMap
-Hierarchy (view full)
- OperationHttpHandler
- StreamingHttpRequestHandler
Index
Constructors
constructor
- new
Streaming Http Request Handler(streamMap, pathPrefix, generator, serializer, credentialsExtractor, permissionReader, authorizer): StreamingHttpRequestHandler Parameters
- streamMap: StreamingHttpMap
- pathPrefix: string
- generator: NotificationGenerator
- serializer: NotificationSerializer
- credentialsExtractor: CredentialsExtractor
- permissionReader: PermissionReader
- authorizer: Authorizer
Returns StreamingHttpRequestHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class SubdomainExtensionBasedMapper
Extends the functionality of an ExtensionBasedMapper to support identifiers containing subdomains. -This is mostly only relevant in case you want to support multiple pods with subdomain identifiers -in a single ResourceStore.
-When converting to/from file paths, the subdomain is interpreted as a folder in the rootFilePath.
-The rest of the path is then interpreted relative to that folder.
-E.g. http://alice.test.com/foo results in the relative path /alice/foo.
In case there is no subdomain in the URL, the baseSubdomain parameter is used instead.
-E.g., if the baseSubdomain is "www", http://test.com/foo would result in the relative path /www/foo.
-This means that there is no identifier that maps to the rootFilePath itself.
-To prevent the possibility of 2 identifiers linking to the same file,
-identifiers containing the default subdomain are rejected.
-E.g., http://www.test.com/foo would result in a 403, even if http://test.com/foo exists.
Hierarchy (view full)
- ExtensionBasedMapper
- SubdomainExtensionBasedMapper
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Subdomain Extension Based Mapper(base, rootFilepath, baseSubdomain?, customTypes?): SubdomainExtensionBasedMapper Parameters
- base: string
- rootFilepath: string
- baseSubdomain: string = 'www'
OptionalcustomTypes: Record<string, string>
Returns SubdomainExtensionBasedMapper
Properties
Protected Readonlybase
Protected Readonlylogger
Protected Readonlyroot
Protected Readonlyunknown
Methods
Protectedget
Protectedget
Protectedget
Protectedget
- get
Content Type From Url(identifier, contentType?): Promise<string> Determines the content type from the document identifier.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<string>
The content type of the document.
-- identifier: ResourceIdentifier
Protectedget
Protectedget
- get
Relative Path(identifier): string Gets the relative path as though the subdomain url is the base, and then prepends it with the subdomain. -Examples assuming http://test.com/ is the base url and
-wwwthe base subdomain:-
-
- http://test.com/foo gives /www/foo -
- http://alice.test.com/foo/ gives /alice/foo/ -
Parameters
- identifier: ResourceIdentifier
Returns string
Protectedis
map
- map
File Path To Url(filePath, isContainer): Promise<ResourceLink> Maps the given file path to a URL and determines its content type.
-Parameters
- filePath: string
The input file path.
- - isContainer: boolean
If the path corresponds to a file.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- filePath: string
Protectedmap
- map
Url To Container Path(identifier, filePath): Promise<ResourceLink> Maps the given container identifier to a file path, -possibly making alterations to the direct translation.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedmap
- map
Url To Document Path(identifier, filePath, contentType?): Promise<ResourceLink> Maps the given document identifier to a file path, -possibly making alterations to the direct translation -(for instance, based on its content type)). -Determines the content type if none was provided.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - filePath: string
The direct translation of the identifier onto the file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
map
- map
Url To File Path(identifier, isMetadata, contentType?): Promise<ResourceLink> Maps the given resource identifier / URL to a file path. -Determines the content type if none was provided. -For containers the content-type input is ignored.
-Parameters
- identifier: ResourceIdentifier
The input identifier.
- - isMetadata: boolean
If we need the data or metadata file path.
- OptionalcontentType: stringThe content-type provided with the request.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Protectedrelative
- relative
To Url(relative): string Converts a relative path to a URL. -Examples assuming http://test.com/ is the base url and
-wwwthe base subdomain:-
-
- /www/foo gives http://test.com/foo -
- /alice/foo/ gives http://alice.test.com/foo/ -
Parameters
- relative: string
Returns string
Protectedstrip
Protectedvalidate
- validate
Relative Path(path, identifier): void Check whether the given relative path is valid.
-Parameters
- path: string
A relative path, as generated by getRelativePath.
- - identifier: ResourceIdentifier
A resource identifier.
-
Returns void
- path: string
Class SubdomainIdentifierGenerator
Generates identifiers by using the name as a subdomain on the base URL.
-Non-alphanumeric characters will be replaced with -.
When extracting the pod, the base URl is also seen as a pod as there is no issue of nested containers here.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Subdomain Identifier Generator(baseUrl): SubdomainIdentifierGenerator Parameters
- baseUrl: string
Returns SubdomainIdentifierGenerator
Methods
extract
- extract
Pod(identifier): ResourceIdentifier Extracts the root pod this identifier would be in. -This assumes the identifier of that pod was generated by the same instance of this interface.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
generate
- generate(name): ResourceIdentifier
Generates container identifiers based on an input name. -This is simply string generation, no resource-related checks are run.
-Parameters
- name: string
Returns ResourceIdentifier
Class SubdomainIdentifierStrategy
An IdentifierStrategy that interprets all subdomains of the given base URL as roots.
-Hierarchy (view full)
- BaseIdentifierStrategy
- SubdomainIdentifierStrategy
Index
Constructors
constructor
- new
Subdomain Identifier Strategy(baseUrl): SubdomainIdentifierStrategy Parameters
- baseUrl: string
Returns SubdomainIdentifierStrategy
Methods
contains
- contains(container, identifier, transitive): boolean
Checks if the given container would contain the given identifier. -This does not check that either of these identifiers actually exist. -This is similar to calling getParentContainer on an identifier -and comparing the result.
-If
-transitiveisfalsethis only checks ifcontaineris the direct parent container ofidentifier.Parameters
- container: ResourceIdentifier
- identifier: ResourceIdentifier
- transitive: boolean
Returns boolean
get
- get
Parent Container(identifier): ResourceIdentifier Generates the identifier of the container this resource would be a member of. -This does not check if that identifier actually exists. -Will throw an error if the input identifier is a root container or is not supported.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
is
- is
Root Container(identifier): boolean Checks if the input corresponds to the identifier of a root container. -This does not check if this identifier actually exists.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
supports
- supports
Identifier(identifier): boolean Verifies if this identifier is supported. -This does not check if this identifier actually exists, -but checks if the identifier is in scope for this class.
-Parameters
- identifier: ResourceIdentifier
Returns boolean
Class SubfolderResourcesGenerator
Generates all resources found in specific subfolders of the given template folder. -In case the same resource is defined in several subfolders, -the data of the last subfolder in the list will be used.
-The results of all the subfolders will be merged so the end result is still a sorted stream of identifiers.
-One of the main use cases for this class is so template resources can be in a separate folder -than their corresponding authorization resources, -allowing for authorization-independent templates.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Subfolder Resources Generator(resourcesGenerator, subfolders): SubfolderResourcesGenerator Parameters
- resourcesGenerator: TemplatedResourcesGenerator
- subfolders: string[]
Returns SubfolderResourcesGenerator
Methods
generate
- generate(templateFolder, location, options): AsyncIterable<Resource>
Generates resources with the given options, based on the given template folder. -The output Iterable should be sorted so that containers always appear before their contents.
-Parameters
- templateFolder: string
Folder where the templates are located.
- - location: ResourceIdentifier
Base identifier.
- - options: Dict<unknown>
Options that can be used when generating resources.
-
Returns AsyncIterable<Resource>
A map where the keys are the identifiers and the values the corresponding representations to store.
-- templateFolder: string
Class SuffixAuxiliaryIdentifierStrategy
Helper class that uses a suffix to determine if a resource is an auxiliary resource or not. -Simple string matching is used, so the dot needs to be included if needed, e.g. ".acl".
-Implements
Index
Constructors
constructor
- new
Suffix Auxiliary Identifier Strategy(suffix): SuffixAuxiliaryIdentifierStrategy Parameters
- suffix: string
Returns SuffixAuxiliaryIdentifierStrategy
Methods
get
- get
Auxiliary Identifier(identifier): ResourceIdentifier Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the corresponding auxiliary resource.
-- identifier: ResourceIdentifier
get
- get
Auxiliary Identifiers(identifier): ResourceIdentifier[] Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
get
- get
Subject Identifier(identifier): ResourceIdentifier Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
- is
Auxiliary Identifier(identifier): boolean Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
Class SuffixIdentifierGenerator
Generates identifiers by appending the name to a stored base identifier.
-Non-alphanumeric characters will be replaced with -.
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Suffix Identifier Generator(base): SuffixIdentifierGenerator Parameters
- base: string
Returns SuffixIdentifierGenerator
Methods
extract
- extract
Pod(identifier): ResourceIdentifier Extracts the root pod this identifier would be in. -This assumes the identifier of that pod was generated by the same instance of this interface.
-Parameters
- identifier: ResourceIdentifier
Returns ResourceIdentifier
generate
- generate(name): ResourceIdentifier
Generates container identifiers based on an input name. -This is simply string generation, no resource-related checks are run.
-Parameters
- name: string
Returns ResourceIdentifier
Class TargetExtractorAbstract
Extracts a ResourceIdentifier from an incoming HttpRequest.
-Hierarchy (view full)
- AsyncHandler<{
request: HttpRequest;
}, ResourceIdentifier>- TargetExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Target Extractor(): TargetExtractor Returns TargetExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<ResourceIdentifier>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<ResourceIdentifier>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<ResourceIdentifier> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<ResourceIdentifier>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class TargetExtractorErrorHandler
Adds metadata to an error to indicate the identifier of the originally targeted resource.
-Hierarchy (view full)
- ErrorHandler
- TargetExtractorErrorHandler
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Target Extractor Error Handler(errorHandler, targetExtractor): TargetExtractorErrorHandler Parameters
- errorHandler: ErrorHandler
- targetExtractor: TargetExtractor
Returns TargetExtractorErrorHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ErrorHandlerArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ErrorHandlerArgs
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: ErrorHandlerArgs
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ErrorHandlerArgs
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ErrorHandlerArgs
Class TemplateEngine<T>Abstract
Generic interface for classes that implement a template engine. -A template engine renders content into a template.
-Type Parameters
Hierarchy (view full)
- AsyncHandler<TemplateEngineInput<T>, string>
Index
Constructors
Methods
Constructors
constructor
- new
Template Engine<T>(): TemplateEngine<T> Type Parameters
Returns TemplateEngine<T>
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: TemplateEngineInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Abstracthandle
- handle(input): Promise<string>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: TemplateEngineInput<T>
Input that needs to be handled.
-
Returns Promise<string>
A promise resolving when handling is finished.
-- input: TemplateEngineInput<T>
handle
- handle
Safe(input): Promise<string> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: TemplateEngineInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<string>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: TemplateEngineInput<T>
Class TemplatedPodGenerator
Creates a new ResourceStore when creating a pod based on a Components.js configuration.
-Part of the dynamic pod creation.
--
-
- It calls a VariableHandler to add necessary variable values. -E.g. setting the base url variable for components.js to the pod identifier. -
- It filters/cleans the input agent values using VariableHandlers -
- It calls a ComponentsJsFactory with the variables and template location to instantiate a new ResourceStore. -
- It stores these values in the configuration storage, which is used as a permanent storage for pod configurations. -
Implements
Index
Constructors
constructor
- new
Templated Pod Generator(storeFactory, variableHandler, configStorage, baseUrl, configTemplatePath?): TemplatedPodGenerator Parameters
- storeFactory: ComponentsJsFactory
Factory used for Components.js instantiation.
- - variableHandler: VariableHandler
Handler used for setting variable values.
- - configStorage: KeyValueStorage<string, unknown>
Where to store the configuration values to instantiate the store for this pod.
- - baseUrl: string
Base URL of the server.
- OptionalconfigTemplatePath: stringWhere to find the configuration templates.
-
Returns TemplatedPodGenerator
- storeFactory: ComponentsJsFactory
Methods
generate
- generate(settings): Promise<ResourceStore>
Creates a ResourceStore based on the given input. -Should error if there already is a store for the given identifier.
-Parameters
- settings: PodSettings
Parameters to be used for the new pod.
-
Returns Promise<ResourceStore>
A new ResourceStore to be used for the new pod.
-- settings: PodSettings
Class TokenOwnershipValidator
Validates ownership of a WebId by seeing if a specific triple can be added.
-expiration parameter is how long the token should be valid in minutes.
Hierarchy (view full)
- OwnershipValidator
- TokenOwnershipValidator
Index
Constructors
constructor
- new
Token Ownership Validator(storage, expiration?): TokenOwnershipValidator Parameters
- storage: ExpiringStorage<string, string>
- expiration: number = 30
Returns TokenOwnershipValidator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
webId: string;
}Input that could potentially be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
webId: string;
}Input that needs to be handled.
-web
Id: string
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
webId: string;
}Input data that will be handled if it can be handled.
-web
Id: string
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class TypedNotificationHandler
A NotificationHandler that only accepts input for a specific notification channel type.
-Hierarchy (view full)
- NotificationHandler
- TypedNotificationHandler
Index
Constructors
Methods
Constructors
constructor
- new
Typed Notification Handler(type, source): TypedNotificationHandler Parameters
- type: string
- source: NotificationHandler
Returns TypedNotificationHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationHandlerInput
Class TypedRepresentationConverterAbstract
A RepresentationConverter that allows requesting the supported types.
-Hierarchy (view full)
- RepresentationConverter
- TypedRepresentationConverter
Index
Constructors
Methods
Constructors
constructor
- new
Typed Representation Converter(): TypedRepresentationConverter Returns TypedRepresentationConverter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: RepresentationConverterArgs
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Abstractget
- get
Output Types(contentType): Promise<ValuePreferences> Gets the output content types this converter can convert the input type to, mapped to a numerical priority.
-Parameters
- contentType: string
Returns Promise<ValuePreferences>
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: RepresentationConverterArgs
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: RepresentationConverterArgs
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: RepresentationConverterArgs
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: RepresentationConverterArgs
Class UnauthorizedHttpError
An error thrown when an agent is not authorized.
-Hierarchy
- BaseHttpError
- UnauthorizedHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Unauthorized Http Error(message?, options?): UnauthorizedHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns UnauthorizedHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class UnionCredentialsExtractor
Combines the results of several CredentialsExtractors into one. -If multiple of these extractors return a value for the same key, -the last result will be used.
-Hierarchy (view full)
- UnionHandler<CredentialsExtractor>
- UnionCredentialsExtractor
Index
Constructors
constructor
- new
Union Credentials Extractor(extractors): UnionCredentialsExtractor Parameters
- extractors: CredentialsExtractor[]
Returns UnionCredentialsExtractor
Methods
Protectedall
- all
Can Handle(input): Promise<void> Checks if all handlers can handle the input. -If not, throw an error based on the errors of the failed handlers.
-Parameters
- input: HttpRequest
Returns Promise<void>
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
combine
- combine(results): Promise<Credentials>
Combines the results of the handlers into a single output.
-Parameters
- results: Credentials[]
Returns Promise<Credentials>
handle
- handle(input): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpRequest
Input that needs to be handled.
-
Returns Promise<Credentials>
A promise resolving when handling is finished.
-- input: HttpRequest
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class UnionHandler<T>Abstract
Utility handler that allows combining the results of multiple handlers into one.
-Will run the handlers and then call the abstract combine function with the results,
-which then generates the handler's output.
Type Parameters
- T extends AsyncHandler<unknown, unknown>
Hierarchy (view full)
Index
Constructors
constructor
- new
Union Handler<T>(handlers, requireAll?, ignoreErrors?): UnionHandler<T> Creates a new
-UnionHandler.When
-requireAllis false orignoreErrorsis true, -the length of the input tocombinecan vary; -otherwise, it is exactly the number of handlers.Type Parameters
- T extends AsyncHandler<unknown, unknown>
Parameters
- handlers: T[]
The handlers whose output is to be combined.
- - requireAll: boolean = false
If true, will fail if any of the handlers do not support the input. -If false, only the handlers that support the input will be called; -will fail only if none of the handlers can handle the input.
- - ignoreErrors: boolean = !requireAll
If true, ignores handlers that fail by omitting their output; -if false, fails when any handlers fail.
-
Returns UnionHandler<T>
Methods
Protectedall
- all
Can Handle(input): Promise<void> Checks if all handlers can handle the input. -If not, throw an error based on the errors of the failed handlers.
-Parameters
- input: AsyncHandlerInput<T>
Returns Promise<void>
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: AsyncHandlerInput<T>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Protected Abstractcombine
- combine(results): Promise<AsyncHandlerOutput<T>>
Combines the results of the handlers into a single output.
-Parameters
- results: AsyncHandlerOutput<T>[]
Returns Promise<AsyncHandlerOutput<T>>
handle
- handle(input): Promise<AsyncHandlerOutput<T>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: AsyncHandlerInput<T>
Input that needs to be handled.
-
Returns Promise<AsyncHandlerOutput<T>>
A promise resolving when handling is finished.
-- input: AsyncHandlerInput<T>
handle
- handle
Safe(input): Promise<Awaited<ReturnType<T["handle"]>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: AsyncHandlerInput<T>
Input data that will be handled if it can be handled.
-
Returns Promise<Awaited<ReturnType<T["handle"]>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: AsyncHandlerInput<T>
Class UnionPermissionReader
Combines the results of multiple PermissionReaders.
-Every permission in every credential type is handled according to the rule false > true > undefined.
Hierarchy (view full)
- UnionHandler<PermissionReader>
- UnionPermissionReader
Index
Constructors
constructor
- new
Union Permission Reader(readers): UnionPermissionReader Parameters
- readers: PermissionReader[]
Returns UnionPermissionReader
Methods
Protectedall
- all
Can Handle(input): Promise<void> Checks if all handlers can handle the input. -If not, throw an error based on the errors of the failed handlers.
-Parameters
- input: PermissionReaderInput
Returns Promise<void>
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Protectedcombine
- combine(results): Promise<PermissionMap>
Combines the results of the handlers into a single output.
-Parameters
- results: PermissionMap[]
Returns Promise<PermissionMap>
handle
- handle(input): Promise<PermissionMap>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: PermissionReaderInput
Input that needs to be handled.
-
Returns Promise<PermissionMap>
A promise resolving when handling is finished.
-- input: PermissionReaderInput
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class UnionPreferenceParser
Combines the results of multiple PreferenceParsers. -Will throw an error if multiple parsers return a range as these can't logically be combined.
-Hierarchy (view full)
- UnionHandler<PreferenceParser>
- UnionPreferenceParser
Index
Constructors
constructor
- new
Union Preference Parser(parsers): UnionPreferenceParser Parameters
- parsers: PreferenceParser[]
Returns UnionPreferenceParser
Methods
Protectedall
- all
Can Handle(input): Promise<void> Checks if all handlers can handle the input. -If not, throw an error based on the errors of the failed handlers.
-Parameters
- input: {
request: HttpRequest;
}request: HttpRequest
Returns Promise<void>
- input: {
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
request: HttpRequest;
}Input that could potentially be handled.
-request: HttpRequest
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Protectedcombine
- combine(results): Promise<RepresentationPreferences>
Combines the results of the handlers into a single output.
-Parameters
- results: RepresentationPreferences[]
Returns Promise<RepresentationPreferences>
handle
- handle(input): Promise<RepresentationPreferences>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
request: HttpRequest;
}Input that needs to be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<RepresentationPreferences> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
request: HttpRequest;
}Input data that will be handled if it can be handled.
-request: HttpRequest
Returns Promise<RepresentationPreferences>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class UnlinkWebIdHandler
Allows users to remove WebIDs linked to their account.
-Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- UnlinkWebIdHandler
Index
Constructors
Methods
Constructors
constructor
- new
Unlink Web Id Handler(webIdStore, webIdRoute): UnlinkWebIdHandler Parameters
- webIdStore: WebIdStore
- webIdRoute: WebIdLinkRoute
Returns UnlinkWebIdHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class UnsecureConstantCredentialsExtractor
Credentials extractor that authenticates a constant agent -(useful for development or debugging purposes).
-Hierarchy (view full)
- CredentialsExtractor
- UnsecureConstantCredentialsExtractor
Index
Constructors
Methods
Constructors
constructor
- new
Unsecure Constant Credentials Extractor(agent): UnsecureConstantCredentialsExtractor Parameters
- agent: string
Returns UnsecureConstantCredentialsExtractor
- new
Unsecure Constant Credentials Extractor(agent): UnsecureConstantCredentialsExtractor Parameters
- agent: undefined | {
webId: string;
}
Returns UnsecureConstantCredentialsExtractor
- agent: undefined | {
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<Credentials>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class UnsecureWebIdExtractor
Credentials extractor which simply interprets the contents of the Authorization header as a WebID.
-Hierarchy (view full)
- CredentialsExtractor
- UnsecureWebIdExtractor
Index
Constructors
constructor
- new
Unsecure Web Id Extractor(): UnsecureWebIdExtractor Returns UnsecureWebIdExtractor
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpRequest
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
handle
- handle(input): Promise<Credentials>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: HttpRequest
Input that needs to be handled.
-
Returns Promise<Credentials>
A promise resolving when handling is finished.
-- input: HttpRequest
handle
- handle
Safe(input): Promise<Credentials> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpRequest
Input data that will be handled if it can be handled.
-
Returns Promise<Credentials>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpRequest
Class UnsecureWebSocketsProtocol
Provides live update functionality following -the Solid WebSockets API Spec solid-0.1.
-The baseUrl parameter should be the same one that is used to advertise with the Updates-Via header.
Hierarchy (view full)
- WebSocketHandler
- UnsecureWebSocketsProtocol
Implements
Index
Constructors
constructor
- new
Unsecure Web Sockets Protocol(source, baseUrl): UnsecureWebSocketsProtocol Parameters
- source: ActivityEmitter
- baseUrl: string
Returns UnsecureWebSocketsProtocol
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: WebSocketHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: WebSocketHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: WebSocketHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: WebSocketHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
Class UnsupportedAsyncHandler
Handler that does not support any input and will always throw an error.
-Hierarchy (view full)
- AsyncHandler<unknown, never>
- UnsupportedAsyncHandler
Index
Constructors
Methods
Constructors
constructor
- new
Unsupported Async Handler(errorMessage?): UnsupportedAsyncHandler Parameters
OptionalerrorMessage: string
Returns UnsupportedAsyncHandler
Methods
can
handle
- handle(): Promise<never>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<never>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<never> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: unknown
Input data that will be handled if it can be handled.
-
Returns Promise<never>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: unknown
Class UnsupportedMediaTypeHttpError
An error thrown when the media type of incoming data is not supported by a parser.
-Hierarchy
- BaseHttpError
- UnsupportedMediaTypeHttpError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Unsupported Media Type Http Error(message?, options?): UnsupportedMediaTypeHttpError Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns UnsupportedMediaTypeHttpError
Properties
Optional Readonlycause
Readonlyerror
message
Readonlymetadata
name
Optionalstack
Readonlystatus
Static Readonlyis
Checks whether the given error is an instance of this class.
-Static Readonlystatus
The status code corresponding to this error class.
-Static Readonlyuri
A unique URI identifying this error class.
-Class UpdateOwnerHandler
Responsible for adding/updating/deleting owners in pods.
-Hierarchy (view full)
- JsonInteractionHandler
- UpdateOwnerHandler
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Update Owner Handler(podStore, podRoute): UpdateOwnerHandler Parameters
- podStore: PodStore
- podRoute: PodIdRoute
Returns UpdateOwnerHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Protectedfind
- find
Verified Pod(target, accountId?): Promise<{
accountId: string;
baseUrl: string;
id: string;
}> Extract the pod ID from the path and find the associated pod. -Asserts that the given account ID is the creator of this pod.
-Parameters
- target: ResourceIdentifier
OptionalaccountId: string
Returns Promise<{
accountId: string;
baseUrl: string;
id: string;
}>
get
- get
View(__namedParameters): Promise<JsonRepresentation<Dict<Json>>> Parameters
- __namedParameters: JsonInteractionHandlerInput
Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class UpdatePasswordHandler
Allows the password of a login to be updated.
-Hierarchy (view full)
- JsonInteractionHandler<EmptyObject>
- UpdatePasswordHandler
Implements
Index
Constructors
Methods
Constructors
constructor
- new
Update Password Handler(passwordStore, passwordRoute): UpdatePasswordHandler Parameters
- passwordStore: PasswordStore
- passwordRoute: PasswordIdRoute
Returns UpdatePasswordHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
get
- get
View(): Promise<JsonRepresentation<Dict<Json>>> Returns Promise<JsonRepresentation<Dict<Json>>>
handle
- handle(input): Promise<JsonRepresentation<EmptyObject>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<EmptyObject>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<EmptyObject>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class V6MigrationInitializer
Handles migrating account data from v6 to the newer format. -Will only trigger if it is detected that this server was previously started on an older version -and at least one account was found. -Confirmation will be asked to the user through a CLI prompt. -After migration is complete the old data will be removed.
-Hierarchy (view full)
- Initializer
- V6MigrationInitializer
Index
Constructors
Methods
Constructors
constructor
- new
V6 Migration Initializer(args): V6MigrationInitializer Parameters
Returns V6MigrationInitializer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Protectedcreate
- create
Account(account): Promise<undefined | {
accountId: string;
webId: string;
}> Creates a new account based on the account data found in the old storage. -Will always create an account and password entry. -In case
-useIdpis true, will create a WebID link entry. -In case there is an associatedpodBaseUrl, will create a pod and owner entry.Parameters
- account: Account | Settings
Returns Promise<undefined | {
accountId: string;
webId: string;
}>
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Protectedis
Class ValidatingDataAccessor
A ValidatingDataAccessor wraps a DataAccessor such that the data stream is validated while being written. -An AtomicDataAccessor can be used to prevent data being written in case validation fails.
-Hierarchy (view full)
- PassthroughDataAccessor
- ValidatingDataAccessor
Index
Constructors
constructor
- new
Validating Data Accessor(accessor, validator): ValidatingDataAccessor Parameters
- accessor: DataAccessor
- validator: Validator
Returns ValidatingDataAccessor
Methods
can
- can
Handle(representation): Promise<void> Should throw a NotImplementedHttpError if the DataAccessor does not support storing the given Representation.
-Parameters
- representation: Representation
Incoming Representation.
-
Returns Promise<void>
- representation: Representation
delete
- delete
Resource(identifier): Promise<void> Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
- get
Children(identifier): AsyncIterableIterator<RepresentationMetadata> Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
- get
Data(identifier): Promise<Guarded<Readable>> Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
- get
Metadata(identifier): Promise<RepresentationMetadata> Returns the metadata corresponding to the identifier. -If possible, it is suggested to add a
-posix:sizetriple to the metadata indicating the binary size. -This is necessary for range requests.Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
- write
Container(identifier, metadata): Promise<void> Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Document(identifier, data, metadata): Promise<void> Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
- write
Metadata(identifier, metadata): Promise<void> Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Class ValidatorAbstract
Generic interface for classes that validate Representations in some way.
-Hierarchy (view full)
Index
Constructors
Methods
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: ValidatorInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
Abstracthandle
- handle(input): Promise<Representation>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: ValidatorInput
Input that needs to be handled.
-
Returns Promise<Representation>
A promise resolving when handling is finished.
-- input: ValidatorInput
handle
- handle
Safe(input): Promise<Representation> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: ValidatorInput
Input data that will be handled if it can be handled.
-
Returns Promise<Representation>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: ValidatorInput
Class VariableHandlerAbstract
Updates the variables stored in the given agent. -Can be used to set variables that are required for the Components.js instantiation -but which should not be provided by the request. -E.g.: The exact file path (when required) should be determined by the server to prevent abuse.
-Hierarchy (view full)
- AsyncHandler<{
identifier: ResourceIdentifier;
settings: PodSettings;
}>- VariableHandler
Index
Constructors
Methods
Constructors
constructor
- new
Variable Handler(): VariableHandler Returns VariableHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that needs to be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class VariableSetter
A VariableHandler that will set the given variable to the given value, -unless there already is a value for the variable and override is false.
-Hierarchy (view full)
- VariableHandler
- VariableSetter
Index
Constructors
Methods
Constructors
constructor
- new
Variable Setter(variable, value, override?): VariableSetter Parameters
- variable: string
- value: string
- override: boolean = false
Returns VariableSetter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input that could potentially be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
settings: PodSettings;
}Input that needs to be handled.
-settings: PodSettings
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: {
identifier: ResourceIdentifier;
settings: PodSettings;
}Input data that will be handled if it can be handled.
-identifier: ResourceIdentifier
settings: PodSettings
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: {
Class VersionHandler
Adds the current version of the API to the JSON output. -This version number should be updated every time the API changes.
-Hierarchy (view full)
- JsonInteractionHandler
- VersionHandler
Index
Constructors
Methods
Constructors
constructor
- new
Version Handler(source): VersionHandler Parameters
- source: JsonInteractionHandler<Dict<Json>>
Returns VersionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class ViewInteractionHandler
Utility class for the common case of a JsonInteractionHandler -describing the expected input on a GET request which is needed to do a POST request.
-Returns the result of a JsonView on GET requests. -POST requests are sent to the JsonInteractionHandler. -Other methods will be rejected.
-Hierarchy (view full)
- JsonInteractionHandler
- ViewInteractionHandler
Index
Constructors
Methods
Constructors
constructor
- new
View Interaction Handler(source): ViewInteractionHandler Parameters
- source: JsonInteractionHandler<Dict<Json>> & JsonView
Returns ViewInteractionHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: JsonInteractionHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
handle
- handle(input): Promise<JsonRepresentation<Dict<Json>>>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: JsonInteractionHandlerInput
Input that needs to be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving when handling is finished.
-- input: JsonInteractionHandlerInput
handle
- handle
Safe(input): Promise<JsonRepresentation<Dict<Json>>> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: JsonInteractionHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<JsonRepresentation<Dict<Json>>>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: JsonInteractionHandlerInput
Class VoidLocker
A ReadWriteLocker where the locks expire after a given time.
-Implements
Index
Constructors
constructor
- new
Void Locker(): VoidLocker Returns VoidLocker
Methods
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> As ReadWriteLocker.withReadLock but the locked function gets called with a
-maintainLockcallback function -to reset the lock expiration every time it is called. -The resulting promise will reject once the lock expires.Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> As ReadWriteLocker.withWriteLock but the locked function gets called with a
-maintainLock-callback function to reset the lock expiration every time it is called. -The resulting promise will reject once the lock expires.Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
Class VoidLogger
A logger that does nothing on a log message.
-Hierarchy (view full)
- BaseLogger
- VoidLogger
Constructors
constructor
- new
Void Logger(): VoidLogger Returns VoidLogger
Class VoidLoggerFactory
A factory that always returns VoidLogger, which does nothing on log messages.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Void Logger Factory(): VoidLoggerFactory Returns VoidLoggerFactory
Methods
create
- create
Logger(label): VoidLogger Create a logger instance for the given label.
-Parameters
- label: string
A label that is used to identify the given logger.
-
Returns VoidLogger
- label: string
Class WacAllowHttpHandler
Adds all the available permissions to the response metadata, -which can be used to generate the correct WAC-Allow header.
-This class does many things similar to the AuthorizingHttpHandler, -so in general it is a good idea to make sure all these classes cache their results.
-Hierarchy (view full)
- OperationHttpHandler
- WacAllowHttpHandler
Index
Constructors
Methods
Constructors
constructor
- new
Wac Allow Http Handler(args): WacAllowHttpHandler Parameters
- args: WacAllowHttpHandlerArgs
Returns WacAllowHttpHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class WacAllowMetadataWriter
Add the necessary WAC-Allow header values. -Solid, §10.1: "Servers exposing client’s access privileges on a resource URL MUST advertise -by including the WAC-Allow HTTP header in the response of HTTP HEAD and GET requests." -https://solid.github.io/specification/protocol#web-access-control
-Hierarchy (view full)
- MetadataWriter
- WacAllowMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Wac Allow Metadata Writer(): WacAllowMetadataWriter Returns WacAllowMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class WaterfallHandler<TIn, TOut>
A composite handler that tries multiple handlers one by one -until it finds a handler that supports the input. -The handlers will be checked in the order they appear in the input array, -allowing for more fine-grained handlers to check before catch-all handlers.
-Type Parameters
Implements
Index
Constructors
constructor
- new
Waterfall Handler<TIn, TOut>(handlers): WaterfallHandler<TIn, TOut> Creates a new WaterfallHandler that stores the given handlers.
-Type Parameters
Parameters
- handlers: AsyncHandler<TIn, TOut>[]
Handlers over which it will run.
-
Returns WaterfallHandler<TIn, TOut>
- handlers: AsyncHandler<TIn, TOut>[]
Methods
can
- can
Handle(input): Promise<void> Checks whether any of the stored handlers can handle the given input.
-Parameters
- input: TIn
The data that would need to be handled.
-
Returns Promise<void>
A promise resolving if at least 1 handler supports to input, or rejecting if none do.
-- input: TIn
handle
- handle(input): Promise<TOut>
Finds a handler that supports the given input and then lets it handle the given data.
-Parameters
- input: TIn
The data that needs to be handled.
-
Returns Promise<TOut>
A promise corresponding to the handle call of a handler that supports the input. -It rejects if no handlers support the given data.
-- input: TIn
handle
- handle
Safe(input): Promise<TOut> Identical to AsyncHandler.handleSafe but optimized for composite -by only needing 1 canHandle call on members.
-Parameters
- input: TIn
The input data.
-
Returns Promise<TOut>
A promise corresponding to the handle call of a handler that supports the input. -It rejects if no handlers support the given data.
-- input: TIn
Class WebAclReader
Finds the permissions of a resource as defined in the corresponding ACL resource. -Does not make any deductions such as checking parent containers for create permissions -or applying control permissions for ACL resources.
-Specific access checks are done by the provided AccessChecker.
-Hierarchy (view full)
- PermissionReader
- WebAclReader
Index
Constructors
constructor
- new
Web Acl Reader(aclStrategy, resourceSet, aclStore, identifierStrategy, accessChecker): WebAclReader Parameters
- aclStrategy: AuxiliaryIdentifierStrategy
- resourceSet: ResourceSet
- aclStore: ResourceStore
- identifierStrategy: IdentifierStrategy
- accessChecker: AccessChecker
Returns WebAclReader
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: PermissionReaderInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
handle
- handle(__namedParameters): Promise<PermissionMap>
Checks if an agent is allowed to execute the requested actions. -Will throw an error if this is not the case.
-Parameters
- __namedParameters: PermissionReaderInput
Returns Promise<PermissionMap>
handle
- handle
Safe(input): Promise<PermissionMap> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: PermissionReaderInput
Input data that will be handled if it can be handled.
-
Returns Promise<PermissionMap>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: PermissionReaderInput
Class WebSocket2023Emitter
Emits notifications on WebSocketChannel2023 subscription. -Uses the WebSockets found in the provided map. -The key should be the identifier of the matching channel.
-Hierarchy (view full)
- NotificationEmitter
- WebSocket2023Emitter
Index
Constructors
constructor
- new
Web Socket2023 Emitter(socketMap): WebSocket2023Emitter Parameters
- socketMap: SetMultiMap<string, WebSocket>
Returns WebSocket2023Emitter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationEmitterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationEmitterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationEmitterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationEmitterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
Class WebSocket2023HandlerAbstract
A handler that is called when a valid WebSocketChannel2023 connection has been made.
-Hierarchy (view full)
- AsyncHandler<WebSocket2023HandlerInput>
- WebSocket2023Handler
Index
Constructors
Methods
Constructors
constructor
- new
Web Socket2023 Handler(): WebSocket2023Handler Returns WebSocket2023Handler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: WebSocket2023HandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocket2023HandlerInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: WebSocket2023HandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: WebSocket2023HandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: WebSocket2023HandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocket2023HandlerInput
Class WebSocket2023Listener
Listens for WebSocket connections and verifies whether they are valid WebSocketChannel2023 connections, -in which case its WebSocket2023Handler will be alerted.
-Hierarchy (view full)
- WebSocketHandler
- WebSocket2023Listener
Index
Constructors
constructor
- new
Web Socket2023 Listener(storage, handler, baseUrl): WebSocket2023Listener Parameters
- storage: NotificationChannelStorage
- handler: WebSocket2023Handler
- baseUrl: string
Returns WebSocket2023Listener
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: WebSocketHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: WebSocketHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: WebSocketHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: WebSocketHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
Class WebSocket2023Storer
Keeps track of the WebSockets that were opened for a WebSocketChannel2023 channel. -The WebSockets are stored in the map using the identifier of the matching channel.
-cleanupTimer defines in minutes how often the stored WebSockets are closed
-if their corresponding channel has expired.
-Defaults to 60 minutes.
-Open WebSockets will not receive notifications if their channel expired.
Hierarchy (view full)
- WebSocket2023Handler
- WebSocket2023Storer
Index
Constructors
constructor
- new
Web Socket2023 Storer(storage, socketMap, cleanupTimer?): WebSocket2023Storer Parameters
- storage: NotificationChannelStorage
- socketMap: SetMultiMap<string, WebSocket>
- cleanupTimer: number = 60
Returns WebSocket2023Storer
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: WebSocket2023HandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocket2023HandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: WebSocket2023HandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: WebSocket2023HandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: WebSocket2023HandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocket2023HandlerInput
Class WebSocketAdvertiser
Handler that advertises a WebSocket through the Updates-Via header.
-Hierarchy (view full)
- HttpHandler
- WebSocketAdvertiser
Index
Constructors
Methods
Constructors
constructor
- new
Web Socket Advertiser(baseUrl): WebSocketAdvertiser Parameters
- baseUrl: string
Returns WebSocketAdvertiser
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: HttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
response: HttpResponse;
}Input that needs to be handled.
-response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: HttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: HttpHandlerInput
Class WebSocketChannel2023Type
The notification channel type WebSocketChannel2023 as described in -https://solid.github.io/notifications/websocket-channel-2023
-Requires read permissions on a resource to be able to receive notifications.
-Hierarchy (view full)
- BaseChannelType
- WebSocketChannel2023Type
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Web Socket Channel2023 Type(route, features?): WebSocketChannel2023Type Parameters
- route: InteractionRoute<never>
Optionalfeatures: string[]
Returns WebSocketChannel2023Type
Properties
Protected Readonlyfeatures
Protected Readonlylogger
Protected Readonlypath
Protected Readonlyshacl
Protected Optionalshacl
Protected Readonlytype
Methods
complete
- complete
Channel(channel): Promise<void> This function will be called after the serialized channel is sent back as a response, -allowing for any final actions that need to happen.
-Parameters
- channel: NotificationChannel
The notification channel that is completed.
-
Returns Promise<void>
- channel: NotificationChannel
extract
- extract
Modes(channel): Promise<AccessMap> Determines which modes are required to allow the given notification channel.
-Parameters
- channel: NotificationChannel
The notification channel to verify.
-
Returns Promise<AccessMap>
The required modes.
-- channel: NotificationChannel
get
- get
Description(): SubscriptionService Returns the SubscriptionService that describes how to subscribe to this channel type.
-Returns SubscriptionService
Protectedget
init
- init
Channel(data, credentials): Promise<WebSocketChannel2023> Initiates the channel by first calling validateSubscription followed by quadsToChannel. -Subclasses can override either function safely to impact the result of the function.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
- credentials: Credentials
Returns Promise<WebSocketChannel2023>
Protectedquads
- quads
To Channel(data, subject): Promise<NotificationChannel> Converts a set of quads to a NotificationChannel. -Assumes the data is valid, so this should be called after validateSubscription.
-The generated identifier will be a URL made by combining the base URL of the channel type with a unique identifier.
-The values of the default features will be added to the resulting channel, -subclasses with additional features that need to be added are responsible for parsing those quads.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
Data to convert.
- - subject: Term
The identifier of the notification channel description in the dataset.
-
Returns Promise<NotificationChannel>
The generated NotificationChannel.
-- data: Store<Quad, Quad, Quad, Quad>
to
- to
Json Ld(channel): Promise<Record<string, unknown>> Converts the given channel to a JSON-LD description. -All fields found in the channel, except
-lastEmit, will be part of the result subject, -so subclasses should remove any fields that should not be exposed.Parameters
- channel: NotificationChannel
Returns Promise<Record<string, unknown>>
Protectedvalidate
- validate
Subscription(data): Promise<Term> Validates whether the given data conforms to the stored SHACL shape. -Will throw an UnprocessableEntityHttpError if validation fails. -Along with the SHACL check, this also makes sure there is only one matching entry in the dataset.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
The data to validate.
-
Returns Promise<Term>
The focus node that corresponds to the subject of the found notification channel description.
-- data: Store<Quad, Quad, Quad, Quad>
Class WebSocketHandlerAbstract
A handler to support requests trying to open a WebSocket connection.
-Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Web Socket Handler(): WebSocketHandler Returns WebSocketHandler
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: WebSocketHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
Abstracthandle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: WebSocketHandlerInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: WebSocketHandlerInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: WebSocketHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: WebSocketHandlerInput
Class WebSocketMap
A SetMultiMap linking identifiers to a set of WebSockets. -An extension of WrappedSetMultiMap to make sure Components.js allows us to create this in the config, -as WrappedSetMultiMap has a constructor not supported.
-Hierarchy (view full)
- WrappedSetMultiMap<string, WebSocket>
- WebSocketMap
Implements
Index
Constructors
constructor
- new
Web Socket Map(mapConstructor?, iterable?): WebSocketMap Parameters
- mapConstructor: (new () => Map<string, Set<WebSocket>>) = Map
Will be used to instantiate the internal Map.
-- new (): Map<string, Set<WebSocket>>
Returns Map<string, Set<WebSocket>>
Optionaliterable: Iterable<readonly [string, WebSocket | ReadonlySet<WebSocket>]>Entries to add to the map.
-
Returns WebSocketMap
- mapConstructor: (new () => Map<string, Set<WebSocket>>) = Map
Methods
[iterator]
add
as
clear
delete
delete
distinct
entries
entry
for
- for
Each(callbackfn, thisArg?): void Loops over all key/value bindings.
-Parameters
- callbackfn: ((value: WebSocket, key: string, map: SetMultiMap<string, WebSocket>) => void)
- (value, key, map): void
Parameters
- value: WebSocket
- key: string
- map: SetMultiMap<string, WebSocket>
Returns void
OptionalthisArg: unknown
Returns void
- callbackfn: ((value: WebSocket, key: string, map: SetMultiMap<string, WebSocket>) => void)
get
has
has
keys
set
value
values
Class WebSocketServerConfigurator
ServerConfigurator that adds WebSocket functionality to an existing Server.
-Listens for WebSocket requests and sends them to its handler.
-Hierarchy (view full)
- ServerConfigurator
- WebSocketServerConfigurator
Index
Constructors
constructor
- new
Web Socket Server Configurator(handler): WebSocketServerConfigurator Parameters
- handler: WebSocketHandler
Returns WebSocketServerConfigurator
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
handle
- handle(server): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- server: Server<typeof IncomingMessage, typeof ServerResponse>
Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: Server<typeof IncomingMessage, typeof ServerResponse>
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: Server<typeof IncomingMessage, typeof ServerResponse>
Class WebhookChannel2023Type
The notification channel type WebhookChannel2023 as described in -https://solid.github.io/notifications/webhook-channel-2023
-Requires read permissions on a resource to be able to receive notifications.
-Also handles the state feature if present.
Hierarchy (view full)
- BaseChannelType
- WebhookChannel2023Type
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Webhook Channel2023 Type(route, webIdRoute, stateHandler, features?): WebhookChannel2023Type Parameters
- route: InteractionRoute<never>
The route corresponding to the URL of the subscription service of this channel type.
- - webIdRoute: InteractionRoute<never>
The route to the WebID that needs to be used when generating DPoP tokens for notifications.
- - stateHandler: StateHandler
The StateHandler that will be called after a successful subscription.
- Optionalfeatures: string[]The features that need to be enabled for this channel type.
-
Returns WebhookChannel2023Type
- route: InteractionRoute<never>
Properties
Protected Readonlyfeatures
Protected Readonlylogger
Protected Readonlypath
Protected Readonlyshacl
Protected Optionalshacl
Protected Readonlytype
Methods
complete
- complete
Channel(channel): Promise<void> This function will be called after the serialized channel is sent back as a response, -allowing for any final actions that need to happen.
-Parameters
- channel: NotificationChannel
The notification channel that is completed.
-
Returns Promise<void>
- channel: NotificationChannel
extract
- extract
Modes(channel): Promise<AccessMap> Determines which modes are required to allow the given notification channel.
-Parameters
- channel: NotificationChannel
The notification channel to verify.
-
Returns Promise<AccessMap>
The required modes.
-- channel: NotificationChannel
get
- get
Description(): SubscriptionService Returns the SubscriptionService that describes how to subscribe to this channel type.
-Returns SubscriptionService
Protectedget
init
- init
Channel(data): Promise<WebhookChannel2023> Initiates the channel by first calling validateSubscription followed by quadsToChannel. -Subclasses can override either function safely to impact the result of the function.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
Returns Promise<WebhookChannel2023>
Protectedquads
- quads
To Channel(data, subject): Promise<NotificationChannel> Converts a set of quads to a NotificationChannel. -Assumes the data is valid, so this should be called after validateSubscription.
-The generated identifier will be a URL made by combining the base URL of the channel type with a unique identifier.
-The values of the default features will be added to the resulting channel, -subclasses with additional features that need to be added are responsible for parsing those quads.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
Data to convert.
- - subject: Term
The identifier of the notification channel description in the dataset.
-
Returns Promise<NotificationChannel>
The generated NotificationChannel.
-- data: Store<Quad, Quad, Quad, Quad>
to
- to
Json Ld(channel): Promise<Record<string, unknown>> Converts the given channel to a JSON-LD description. -All fields found in the channel, except
-lastEmit, will be part of the result subject, -so subclasses should remove any fields that should not be exposed.Parameters
- channel: NotificationChannel
Returns Promise<Record<string, unknown>>
Protectedvalidate
- validate
Subscription(data): Promise<Term> Validates whether the given data conforms to the stored SHACL shape. -Will throw an UnprocessableEntityHttpError if validation fails. -Along with the SHACL check, this also makes sure there is only one matching entry in the dataset.
-Parameters
- data: Store<Quad, Quad, Quad, Quad>
The data to validate.
-
Returns Promise<Term>
The focus node that corresponds to the subject of the found notification channel description.
-- data: Store<Quad, Quad, Quad, Quad>
Class WebhookEmitter
Emits a notification representation using the WebhookChannel2023 specification.
-At the time of writing it is not specified how exactly a notification sender should make its requests verifiable, -so for now we use a token similar to those from Solid-OIDC, signed by the server itself.
-Generates a DPoP token and proof, and adds those to the HTTP request that is sent to the target.
-The expiration input parameter is how long the generated token should be valid in minutes.
-Default is 20.
Hierarchy (view full)
- NotificationEmitter
- WebhookEmitter
Index
Constructors
constructor
- new
Webhook Emitter(baseUrl, webIdRoute, jwkGenerator, expiration?): WebhookEmitter Parameters
- baseUrl: string
- webIdRoute: InteractionRoute<never>
- jwkGenerator: JwkGenerator
- expiration: number = 20
Returns WebhookEmitter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: NotificationEmitterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: NotificationEmitterInput
Input that needs to be handled.
-
Returns Promise<void>
A promise resolving when handling is finished.
-- input: NotificationEmitterInput
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: NotificationEmitterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: NotificationEmitterInput
Class WebhookWebId
Generates a fixed WebID that we use to identify the server for notifications sent using a WebhookChannel2023.
-This is used in tandem with the tokens generated by the WebhookEmitter.
-This is a minimal WebID with only the solid:oidcIssuer triple.
Hierarchy (view full)
- OperationHttpHandler
- WebhookWebId
Index
Constructors
Methods
Constructors
constructor
- new
Webhook Web Id(baseUrl): WebhookWebId Parameters
- baseUrl: string
Returns WebhookWebId
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: OperationHttpHandlerInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
handle
- handle(input): Promise<ResponseDescription>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: OperationHttpHandlerInput
Input that needs to be handled.
-
Returns Promise<ResponseDescription>
A promise resolving when handling is finished.
-- input: OperationHttpHandlerInput
handle
- handle
Safe(input): Promise<ResponseDescription> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: OperationHttpHandlerInput
Input data that will be handled if it can be handled.
-
Returns Promise<ResponseDescription>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: OperationHttpHandlerInput
Class WinstonLogger
A WinstonLogger implements the Logger interface using a given winston logger.
-Hierarchy (view full)
- BaseLogger
- WinstonLogger
Constructors
constructor
- new
Winston Logger(logger): WinstonLogger Parameters
- logger: Logger
Returns WinstonLogger
Methods
debug
error
info
log
- log(level, message, meta?): this
Log the given message at the given level. -If the internal level is higher than the given level, the message may be voided.
-Parameters
- level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly"The level to log at.
- - message: string
The message to log.
- Optionalmeta: unknownOptional metadata to include in the log message.
-
Returns this
- level:
silly
verbose
warn
Class WinstonLoggerFactory
Uses the winston library to create loggers for the given logging level. -By default, it will print to the console with colorized logging levels.
-This creates instances of WinstonLogger.
-Implements
Index
Constructors
Methods
Constructors
constructor
- new
Winston Logger Factory(level): WinstonLoggerFactory Parameters
- level: string
Returns WinstonLoggerFactory
Class WorkerManager
Spawns the necessary workers when starting in multithreaded mode.
-Hierarchy (view full)
- Initializer
- WorkerManager
Index
Constructors
Methods
Constructors
constructor
- new
Worker Manager(clusterManager): WorkerManager Parameters
- clusterManager: ClusterManager
Returns WorkerManager
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: void
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
handle
- handle(): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Returns Promise<void>
A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: void
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: void
Class WrappedExpiringReadWriteLocker
Wraps around an existing ReadWriteLocker and adds expiration logic to prevent locks from getting stuck.
-Implements
Index
Constructors
constructor
- new
Wrapped Expiring Read Write Locker(locker, expiration): WrappedExpiringReadWriteLocker Parameters
- locker: ReadWriteLocker
Instance of ResourceLocker to use for acquiring a lock.
- - expiration: number
Time in ms after which the lock expires.
-
Returns WrappedExpiringReadWriteLocker
- locker: ReadWriteLocker
Properties
Protected Readonlyexpiration
Protected Readonlylocker
Protected Readonlylogger
Methods
with
- with
Read Lock<T>(identifier, whileLocked): Promise<T> As ReadWriteLocker.withReadLock but the locked function gets called with a
-maintainLockcallback function -to reset the lock expiration every time it is called. -The resulting promise will reject once the lock expires.Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
with
- with
Write Lock<T>(identifier, whileLocked): Promise<T> As ReadWriteLocker.withWriteLock but the locked function gets called with a
-maintainLock-callback function to reset the lock expiration every time it is called. -The resulting promise will reject once the lock expires.Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
Class WrappedExpiringStorage<TKey, TValue>
A storage that wraps around another storage and expires resources based on the given (optional) expiry date. -Will delete expired entries when trying to get their value. -Has a timer that will delete all expired data every hour (default value).
-Type Parameters
Implements
Constructors
constructor
- new
Wrapped Expiring Storage<TKey, TValue>(source, timeout?): WrappedExpiringStorage<TKey, TValue> Type Parameters
Parameters
- source: KeyValueStorage<TKey, Expires<TValue>>
KeyValueStorage to actually store the data.
- - timeout: number = 60
How often the expired data needs to be checked in minutes.
-
Returns WrappedExpiringStorage<TKey, TValue>
- source: KeyValueStorage<TKey, Expires<TValue>>
Methods
delete
- delete(key): Promise<boolean>
Deletes the value stored for the given key.
-Parameters
- key: TKey
Key to delete.
-
Returns Promise<boolean>
If there was a value to delete.
-- key: TKey
entries
get
has
- has(key): Promise<boolean>
Checks whether there is a value stored for the given key.
-Parameters
- key: TKey
Returns Promise<boolean>
set
- set(key, value, expiration?): Promise<WrappedExpiringStorage<TKey, TValue>>
Sets the value for the given key. -Should error if the data is already expired.
-Parameters
Returns Promise<WrappedExpiringStorage<TKey, TValue>>
The storage.
-- set(key, value, expires?): Promise<WrappedExpiringStorage<TKey, TValue>>
Sets the value for the given key. -Should error if the data is already expired.
-Returns Promise<WrappedExpiringStorage<TKey, TValue>>
The storage.
-
Class WrappedIndexedStorage<T>
An IndexedStorage that makes use of 2 KeyValueStorages to implement the interface. -Due to being limited by key/value storages, there are some restrictions on the allowed type definitions:
--
-
- There needs to be exactly 1 type with no references to other types. -
- All other types need to have exactly 1 reference to another type. -
- Types can't reference each other to create a cycle of references. -
All of the above to create a tree-like structure of references. -Such a tree is then stored in one of the storages. -The other storage is used to store all indexes that are used to find the correct tree object when solving queries.
-Type Parameters
- T extends IndexTypeCollection<T>
Implements
Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
- new
Wrapped Indexed Storage<T>(valueStorage, indexStorage): WrappedIndexedStorage<T> Type Parameters
- T extends IndexTypeCollection<T>
Parameters
- valueStorage: KeyValueStorage<string, VirtualObject>
- indexStorage: KeyValueStorage<string, string[]>
Returns WrappedIndexedStorage<T>
Accessors
Protectedroot
- get rootType(): string
The root type for this storage. -Use this instead of rootTypeVar to prevent having to check for
-undefined. -This value will always be defined if the type definitions have been validated.Returns string
Methods
create
- create<TType>(type, value): Promise<TypeObject<T[TType]>>
Creates an object of the given type. -The storage will generate an identifier for the newly created object.
-Type Parameters
Parameters
- type: TType
The type to create.
- - value: CreateTypeObject<T[TType]>
The value to set for the created object.
-
Returns Promise<TypeObject<T[TType]>>
A representation of the newly created object, including its new identifier.
-- type: TType
create
- create
Index<TType>(type, key): Promise<void> Creates an index on a key of the given type, to allow for better queries involving those keys. -Similar to IndexedStorage.defineType these calls need to happen first.
-Type Parameters
Parameters
Returns Promise<void>
define
- define
Type<TType>(type, description): Promise<void> Informs the storage of the definition of a specific type. -A definition is a key/value object with the values being a valid ValueTypeDescription. -Generally, this call needs to happen for every type of this storage, -and before any calls are made to interact with the data.
-Type Parameters
Parameters
Returns Promise<void>
delete
- delete<TType>(type, id): Promise<void>
Deletes the given object. -This will also delete all objects that reference that object if the corresponding key is not optional.
-Type Parameters
Parameters
- type: TType
The type of the object to delete.
- - id: string
The identifier of the object.
-
Returns Promise<void>
- type: TType
entries
- entries<TType>(type): AsyncIterableIterator<TypeObject<T[TType]>>
Returns an iterator over all objects of the given type.
-Type Parameters
Parameters
- type: TType
The type to iterate over.
-
Returns AsyncIterableIterator<TypeObject<T[TType]>>
- type: TType
find
- find<TType>(type, query): Promise<TypeObject<T[TType]>[]>
Finds all objects matching a specific IndexedQuery.
-Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<TypeObject<T[TType]>[]>
A list of objects matching the query.
-- type: TType
find
- find
Ids<TType>(type, query): Promise<string[]> Similar to IndexedStorage.find, but only returns the identifiers of the found objects.
-Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<string[]>
A list of identifiers of the matching objects.
-- type: TType
Protectedfind
- find
Indexed Roots<TType>(type, match, rootIds?): Promise<undefined | string[]> Finds the IDs of all root objects that contain objects of the given type matching the given query -by making use of the indexes applicable to the keys in the query. -This function only looks at the keys in the query with primitive values, -object values in the query referencing parent objects are not considered. -Similarly, only indexes are used, keys without index are also ignored.
-If an array of root IDs is provided as input, -the result will be an intersection of this array and the found identifiers.
-If the result is an empty array, it means that there is no valid identifier matching the query, -while an
-undefinedresult means there is no index matching any of the query keys, -so a result can't be determined.Type Parameters
Parameters
- type: TType
- match: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
} OptionalrootIds: string[]
Returns Promise<undefined | string[]>
get
- get<TType>(type, id): Promise<undefined | TypeObject<T[TType]>>
Returns the object of the given type with the given identifier.
-Type Parameters
Parameters
- type: TType
The type of object to get.
- - id: string
The identifier of that object.
-
Returns Promise<undefined | TypeObject<T[TType]>>
A representation of the object, or
-undefinedif there is no object of that type with that identifier.- type: TType
Protectedget
- get
Child Objects(obj, path): VirtualObject[] Finds all objects in the provided object that can be found by following the provided path of virtual keys.
-Parameters
- obj: VirtualObject
- path: `**${string}**`[]
Returns VirtualObject[]
Protectedget
- get
Child Relations<TType>(type): IndexRelation<T>[] Returns all relations where the given type is the parent.
-Type Parameters
Parameters
- type: TType
Returns IndexRelation<T>[]
Protectedget
- get
Containing Record<TType>(rootObj, type, id): Record<string, VirtualObject> Finds the record in the given object that contains the given type/id combination. -This function assumes it was already verified through an index that this object contains the given combination.
-Type Parameters
Parameters
- rootObj: VirtualObject
- type: TType
- id: string
Returns Record<string, VirtualObject>
Protectedget
Protectedget
- get
Parent Relation<TType>(type): undefined | IndexRelation<T> Returns the relation where the given type is the child. -Will return
-undefinedfor the root type as that one doesn't have a parent.Type Parameters
Parameters
- type: TType
Returns undefined | IndexRelation<T>
Protectedget
- get
Path Records(obj, path): Record<string, VirtualObject>[] Finds all records that can be found in the given object by following the given path of virtual keys.
-Parameters
- obj: VirtualObject
- path: `**${string}**`[]
Returns Record<string, VirtualObject>[]
Protectedget
Protectedget
- get
Root<TType>(type, id): Promise<undefined | VirtualObject> Finds the root object that contains the requested type/id combination.
-Type Parameters
Parameters
- type: TType
- id: string
Returns Promise<undefined | VirtualObject>
has
set
- set<TType>(type, value): Promise<void>
Sets the value of a specific object. -The identifier in the object is used to identify the object.
-Type Parameters
Parameters
- type: TType
The type of the object to set.
- - value: TypeObject<T[TType]>
The new value for the object.
-
Returns Promise<void>
- type: TType
set
Protectedsolve
- solve
Query<TType>(type, query, rootIds?): Promise<VirtualObject[]> Finds all objects of the given type matching the query. -The
-rootIdsarray can be used to restrict the IDs of root objects to look at, -which is relevant for the recursive calls the function does.Will throw an error if there is no index that can be used to solve the query.
-Type Parameters
Parameters
- type: TType
- query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
} OptionalrootIds: string[]
Returns Promise<VirtualObject[]>
Protectedto
- to
Type Object<TType>(type, obj): TypeObject<T[TType]> Converts a VirtualObject into a TypeObject. -To be used when outputting results.
-Type Parameters
Parameters
- type: TType
- obj: VirtualObject
Returns TypeObject<T[TType]>
Protectedupdate
- update
Deep Type Index<TType>(type, rootId, oldObj, newObj?): Promise<void> Update all indexes for an object of the given type, and all its children.
-Type Parameters
Parameters
- type: TType
- rootId: string
- oldObj: VirtualObject
OptionalnewObj: VirtualObject
Returns Promise<void>
Protectedupdate
Protectedupdate
- update
Type Index<TType>(type, rootId, oldObj?, newObj?): Promise<void> Updates all indexes for an object of the given type.
-Type Parameters
Parameters
- type: TType
- rootId: string
OptionaloldObj: VirtualObjectOptionalnewObj: VirtualObject
Returns Promise<void>
Protectedupdate
- update
Value<TType>(type, value, replace): Promise<void> Replaces an object of the given type. -The identifier in the value is used to determine which object.
-Type Parameters
Parameters
- type: TType
- value: TypeObject<T[TType]>
- replace: true
Returns Promise<void>
- update
Value<TType>(type, partial, replace): Promise<void> Replaces part of an object of the given type with the given partial value. -The identifier in the value is used to determine which object.
-Type Parameters
Parameters
- type: TType
- partial: Partial<TypeObject<T[TType]>> & {
id: string;
} - replace: false
Returns Promise<void>
Protectedvalidate
- validate
Definition(type): void Makes sure the defined types fulfill all the requirements necessary for types on this storage. -Will throw an error if this is not the case. -This should be called before doing any data interactions. -Stores success in a variable so future calls are instantaneous.
-Parameters
- type: string
Returns void
Class WrappedSetMultiMap<TKey, TVal>
A SetMultiMap that uses an internal Map based on the provided constructor.
-In case no input constructor is provided, the default Map implementation will be used.
-It is required that the value type of this map is not Set or any extension of Set,
-otherwise the set and add functions wil break.
Type Parameters
Hierarchy (view full)
- WrappedSetMultiMap
Implements
Index
Constructors
constructor
- new
Wrapped Set Multi Map<TKey, TVal>(mapConstructor?, iterable?): WrappedSetMultiMap<TKey, TVal> Type Parameters
Parameters
Returns WrappedSetMultiMap<TKey, TVal>
Methods
[iterator]
add
as
clear
delete
- delete(key): boolean
Parameters
- key: TKey
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.
-
delete
distinct
entries
entry
for
- for
Each(callbackfn, thisArg?): void Loops over all key/value bindings.
-Parameters
- callbackfn: ((value: TVal, key: TKey, map: SetMultiMap<TKey, TVal>) => void)
- (value, key, map): void
Parameters
- value: TVal
- key: TKey
- map: SetMultiMap<TKey, TVal>
Returns void
OptionalthisArg: unknown
Returns void
- callbackfn: ((value: TVal, key: TKey, map: SetMultiMap<TKey, TVal>) => void)
get
has
- has(key): boolean
Parameters
- key: TKey
Returns boolean
boolean indicating whether an element with the specified key exists or not.
-
has
keys
set
value
values
Class WrappingLogger
Implements BaseLogger around a SimpleLogger, -which can be swapped out a runtime.
-Hierarchy (view full)
- BaseLogger
- WrappingLogger
Constructors
constructor
- new
Wrapping Logger(logger): WrappingLogger Parameters
- logger: SimpleLogger
Returns WrappingLogger
Methods
debug
error
info
log
- log(level, message, meta?): this
Log the given message at the given level. -If the internal level is higher than the given level, the message may be voided.
-Parameters
- level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly"The level to log at.
- - message: string
The message to log.
- Optionalmeta: LogMetadataOptional metadata to include in the log message.
-
Returns this
- level:
silly
verbose
warn
Class WwwAuthMetadataWriter
Adds the WWW-Authenticate header with the injected value in case the response status code is 401.
Hierarchy (view full)
- MetadataWriter
- WwwAuthMetadataWriter
Index
Constructors
Methods
Constructors
constructor
- new
Www Auth Metadata Writer(auth): WwwAuthMetadataWriter Parameters
- auth: string
Returns WwwAuthMetadataWriter
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: MetadataWriterInput
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
handle
- handle(input): Promise<void>
Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- input: {
metadata: RepresentationMetadata;
response: HttpResponse;
}Input that needs to be handled.
-metadata: RepresentationMetadata
response: HttpResponse
Returns Promise<void>
A promise resolving when handling is finished.
-- input: {
handle
- handle
Safe(input): Promise<void> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: MetadataWriterInput
Input data that will be handled if it can be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: MetadataWriterInput
Class YargsCliExtractor
Parses CLI args using the yargs library. -Specific settings can be enabled through the provided options.
-Hierarchy (view full)
- CliExtractor
- YargsCliExtractor
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Yargs Cli Extractor(parameters, options): YargsCliExtractor Parameters
- parameters: YargsParameter[]
Parameters that should be parsed from the CLI.
- - options: CliOptions
Additional options to configure yargs.
-
Returns YargsCliExtractor
Range
JSON parameters cannot be optional due to https://github.com/LinkedSoftwareDependencies/Components-Generator.js/issues/87
-- parameters: YargsParameter[]
Properties
Protected Readonlyyargs
Protected Readonlyyargv
Methods
can
- can
Handle(input): Promise<void> Checks whether the input can be handled by this class. -If it cannot handle the input, rejects with an error explaining why.
-Parameters
- input: CliArgv
Input that could potentially be handled.
-
Returns Promise<void>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: CliArgv
handle
- handle(argv): Promise<{
$0: string;
_: (string | number)[];
[argName: string]: unknown;
}> Handles the given input. This may only be called if canHandle did not reject. -When unconditionally calling both in sequence, consider handleSafe instead.
-Parameters
- argv: readonly string[]
Returns Promise<{
$0: string;
_: (string | number)[];
[argName: string]: unknown;
}>A promise resolving when handling is finished.
-
handle
- handle
Safe(input): Promise<Shorthand> Helper function that first runs canHandle followed by handle. -Throws the error of canHandle if the data cannot be handled, -or returns the result of handle otherwise.
-Parameters
- input: CliArgv
Input data that will be handled if it can be handled.
-
Returns Promise<Shorthand>
A promise resolving if the input can be handled, rejecting with an Error if not.
-- input: CliArgv
Class YargsParameter
This class exists as wrapper around a yargs Options object, -thereby allowing us to create these in a Components.js configuration.
-Format details can be found at https://yargs.js.org/docs/#api-reference-optionskey-opt
- Index
Constructors
Properties
Constructors
constructor
- new
Yargs Parameter(name, options): YargsParameter Parameters
- name: string
Name of the parameter. Corresponds to the first parameter passed to the
-yargs.optionsfunction. - options: Record<string, unknown>
Options for a single parameter that should be parsed.
-
Returns YargsParameter
- name: string
Function absoluteFilePath
- absolute
File Path(path): string Resolves a path to its absolute form. -Absolute inputs will not be changed (except changing Windows to POSIX). -Relative inputs will be interpreted relative to process.cwd().
-Parameters
- path: string
Path to check (POSIX or Windows).
-
Returns string
The potentially changed path (POSIX).
-- path: string
Function addGeneratedResources
- add
Generated Resources(settings, generator, store): Promise<number> Generates resources with the given generator and adds them to the given store.
-Parameters
- settings: PodSettings
Settings from which the pod is being created.
- - generator: ResourcesGenerator
Generator to be used.
- - store: ResourceStore
Store to be updated.
-
Returns Promise<number>
The amount of resources that were added.
-- settings: PodSettings
Function addHeader
- add
Header(response, name, value): void Adds a header value without overriding previous values.
-Parameters
- response: HttpResponse
- name: string
- value: string | string[]
Returns void
Function addResourceMetadata
- add
Resource Metadata(metadata, isContainer): void Helper function to generate type quads for a Container or Resource.
-Parameters
- metadata: RepresentationMetadata
Metadata to add to.
- - isContainer: boolean
If the identifier corresponds to a container.
-
Returns void
- metadata: RepresentationMetadata
Function addTemplateMetadata
- add
Template Metadata(metadata, templateFile, contentType): void Links a template file with a given content-type to the metadata using the SOLID_META.template predicate.
-Parameters
- metadata: RepresentationMetadata
Metadata to update.
- - templateFile: string
Path to the template.
- - contentType: string
Content-type of the template after it is rendered.
-
Returns void
- metadata: RepresentationMetadata
Function allFulfilled
- all
Fulfilled<T>(promises, ignoreErrors?): Promise<T[]> Obtains the values of all fulfilled promises. -If there are rejections (and
-ignoreErrorsis false), throws a combined error of all rejected promises.Type Parameters
Parameters
- promises: Promise<T>[]
- ignoreErrors: boolean = false
Returns Promise<T[]>
Function assertOidcInteraction
- assert
Oidc Interaction(oidcInteraction?): asserts oidcInteraction is Interaction Asserts
-oidcInteractionis defined, throws the correct error in case this is not the case. -The error contains the relevant error code that can be used to explain more extensively what the issue is -and why an OIDC interaction is needed.Parameters
OptionaloidcInteraction: InteractionInteraction object to check.
-
Returns asserts oidcInteraction is Interaction
Function assertReadConditions
- assert
Read Conditions(body, eTagHandler, conditions?): void Verify whether the given Representation matches the given conditions. -If true, add the corresponding ETag to the body metadata. -If not, destroy the data stream and throw a NotModifiedHttpError with the same ETag. -If
-conditionsis not defined, nothing will happen.This uses the strict conditions check which takes the content type into account; -therefore, this should only be called after content negotiation, when it is certain what the output will be.
-Note that browsers only keep track of one ETag, and the Vary header has no impact on this, -meaning the browser could send us the ETag for a Turtle resource even though it is requesting JSON-LD; -this is why we have to check ETags after content negotiation.
-Parameters
- body: Representation
The representation to compare the conditions against.
- - eTagHandler: ETagHandler
Used to generate the ETag to return with the 304 response.
- Optionalconditions: ConditionsThe conditions to assert.
-
Returns void
- body: Representation
Function cleanPreferences
- clean
Preferences(preferences?): ValuePreferences Cleans incoming preferences to prevent unwanted behaviour. -Makes sure internal types have weight 0, unless specifically requested in the preferences, -and interprets empty preferences as accepting everything.
-Parameters
- preferences: ValuePreferences = {}
Preferences that need to be updated.
-
Returns ValuePreferences
A copy of the the preferences with the necessary updates.
-- preferences: ValuePreferences = {}
Function cloneRepresentation
- clone
Representation(representation): Promise<BasicRepresentation> Helper function to clone a representation, the original representation can still be used. -This function loads the entire stream in memory.
-Parameters
- representation: Representation
The representation to clone.
-
Returns Promise<BasicRepresentation>
The cloned representation.
-- representation: Representation
Function createAggregateError
- create
Aggregate Error(errors): HttpError Combines a list of errors into a single HttpError. -Status code depends on the input errors. If they all share the same status code that code will be re-used. -If they are all within the 4xx range, 400 will be used, otherwise 500.
-Parameters
- errors: Error[]
Errors to combine.
-
Returns HttpError
- errors: Error[]
Function createGenericEventEmitterClass
- create
Generic Event Emitter Class<T>(): (new () => T) Creates a class that is an implementation of EventEmitter -but with specific typings based on GenericEventEmitter. -Useful in case a class needs to extend EventEmitter and wants specific internal typings.
-Type Parameters
Returns (new () => T)
Function createSubdomainRegexp
- create
Subdomain Regexp(baseUrl): RegExp Creates a regular expression that matches URLs containing the given baseUrl, or a subdomain of the given baseUrl. -In case there is a subdomain, the first match of the regular expression will be that subdomain.
-Examples with baseUrl
-http://test.com/foo/:-
-
- Will match
http://test.com/foo/
- - Will match
http://test.com/foo/bar/baz
- - Will match
http://alice.bob.test.com/foo/bar/baz, first match result will bealice.bob
- - Will not match
http://test.com/
- - Will not match
http://alicetest.com/foo/
-
Parameters
- baseUrl: string
Base URL for the regular expression.
-
Returns RegExp
- Will match
Function createVocabulary
- create
Vocabulary<TBase, TLocal>(baseUri, ...localNames): string extends TLocal
? PartialVocabulary<TBase>
: Vocabulary<TBase, TLocal> Creates a Vocabulary with the given
-baseUrias namespace and alllocalNamesas entries. -The values are the local names expanded from the given base URI as strings. -Thetermsfield contains all the same values but as NamedNode instead.Type Parameters
Returns string extends TLocal
? PartialVocabulary<TBase>
: Vocabulary<TBase, TLocal>
Function decodeUriPathComponents
- decode
Uri Path Components(path): string This function is used when converting a URI to a file path. Decodes all components of a URI path, -with the exception of encoded slash characters, as this would lead to unexpected file locations -being targeted (resulting in erroneous behaviour of the file based backend). -Characters that would result in an illegal file path remain percent encoded.
-Parameters
- path: string
The path to decode the URI path components of.
-
Returns string
A decoded copy of the provided URI path (ignoring encoded slash characters).
-- path: string
Function encodeUriPathComponents
- encode
Uri Path Components(path): string This function is used in the process of converting a file path to a URI. Encodes all (non-slash) -special characters in a URI path, with the exception of encoded slash characters, as this would -lead to unnecessary double encoding, resulting in a URI that differs from the expected result.
-Parameters
- path: string
The path to encode the URI path components of.
-
Returns string
An encoded copy of the provided URI path (ignoring encoded slash characters).
-- path: string
Function errorTermsToMetadata
- error
Terms To Metadata(terms, metadata?): RepresentationMetadata Adds the given terms to error metadata. -The keys will be converted to predicates by prepending them with the
-SOLID_ERROR_TERMnamespace. -The values will become literals.Parameters
- terms: Dict<string>
Terms to add to the metadata.
- Optionalmetadata: RepresentationMetadataMetadata to add the terms to. A new metadata object will be created if this is undefined.
-
Returns RepresentationMetadata
- terms: Dict<string>
Function extendVocabulary
- extend
Vocabulary<TBase, TLocal, TNew>(vocabulary, ...newNames): ReturnType<typeof createVocabulary> Creates a new Vocabulary that extends an existing one by adding new local names.
-Type Parameters
Parameters
- vocabulary: Vocabulary<TBase, TLocal>
The Vocabulary to extend.
- Rest...newNames: TNew[]The new local names that need to be added.
-
Returns ReturnType<typeof createVocabulary>
- vocabulary: Vocabulary<TBase, TLocal>
Function extractErrorTerms
- extract
Error Terms(metadata): Dict<string> Extracts all the error metadata terms and converts them to a simple object. -All predicates in the
-SOLID_ERROR_TERMnamespace will be found. -The namespace will be removed from the predicate and the remainder will be used as a key. -The object literal values will be used as values in the resulting object.Parameters
- metadata: RepresentationMetadata
Metadata to extract the terms from.
-
Returns Dict<string>
- metadata: RepresentationMetadata
Function extractScheme
- extract
Scheme(url): {
rest: string;
scheme: string;
} Splits a URL (or similar) string into a part containing its scheme and one containing the rest. -E.g.,
-http://test.com/results in{ scheme: 'http://', rest: 'test.com/' }.Parameters
- url: string
String to parse.
-
Returns {
rest: string;
scheme: string;
}rest: string
scheme: string
- url: string
Function fetchDataset
- fetch
Dataset(url): Promise<Representation> Fetches an RDF dataset from the given URL.
-Response will be a Representation with content-type internal/quads.
-Parameters
- url: string
Returns Promise<Representation>
Function filter
- filter<T>(iterable, callbackFn, thisArg?): Iterable<T>
Creates a new iterable with all elements that pass the test implemented by the provided function. -Similar to the Array.prototype.filter function. -See the documentation of the above function for more details.
-Type Parameters
Parameters
- iterable: Iterable<T>
Iterable on which to call the map function.
- - callbackFn: ((element: T, index: number) => boolean)
Function that is called to test every element.
-- (element, index): boolean
Parameters
- element: T
- index: number
Returns boolean
OptionalthisArg: unknownValue to use as
-thiswhen executingcallbackFn.
Returns Iterable<T>
- iterable: Iterable<T>
Function filterHandlers
- filter
Handlers<TIn, TOut>(handlers, input): Promise<AsyncHandler<TIn, TOut>[]> Filters a list of handlers to only keep those that can handle the input. -Will error if no matching handlers are found.
-Type Parameters
Parameters
- handlers: AsyncHandler<TIn, TOut>[]
Handlers to filter.
- - input: TIn
Input that needs to be supported.
-
Returns Promise<AsyncHandler<TIn, TOut>[]>
- handlers: AsyncHandler<TIn, TOut>[]
Function find
- find<T>(iterable, callbackFn, thisArg?): T | undefined
Returns the first element in the provided iterable that satisfies the provided testing function. -If no values satisfy the testing function,
-undefinedis returned. -Similar to the Array.prototype.find function. -See the documentation of the above function for more details.Type Parameters
Parameters
- iterable: Iterable<T>
Iterable on which to call the map function.
- - callbackFn: ((element: T, index: number) => boolean)
Function that is called to test every element.
-- (element, index): boolean
Parameters
- element: T
- index: number
Returns boolean
OptionalthisArg: unknownValue to use as
-thiswhen executingcallbackFn.
Returns T | undefined
- iterable: Iterable<T>
Function findHandler
- find
Handler<TIn, TOut>(handlers, input): Promise<AsyncHandler<TIn, TOut>> Finds a handler that can handle the given input data. -Otherwise an error gets thrown.
-Type Parameters
Parameters
- handlers: AsyncHandler<TIn, TOut>[]
List of handlers to search in.
- - input: TIn
The input data.
-
Returns Promise<AsyncHandler<TIn, TOut>>
A promise resolving to a handler that supports the data or otherwise rejecting.
-- handlers: AsyncHandler<TIn, TOut>[]
Function finishInteraction
- finish
Interaction(oidcInteraction, result, mergeWithLastSubmission): Promise<string> Updates the
-oidcInteractionobject with the necessary data in case a prompt gets updated.Parameters
- oidcInteraction: Interaction
Interaction to update.
- - result: AccountInteractionResults
New data to add to the interaction.
- - mergeWithLastSubmission: boolean
If this new data needs to be merged with already existing data in the interaction.
-
Returns Promise<string>
- oidcInteraction: Interaction
Function forgetWebId
- forget
Web Id(provider, oidcInteraction): Promise<void> Removes the WebID, the
-accountId, from the OIDC session object, -allowing us to replace it with a new value. -If there is no session in the Interaction, nothing will happen.Parameters
- provider: Provider
The OIDC provider.
- - oidcInteraction: Interaction
The current interaction.
-
Returns Promise<void>
- provider: Provider
Function generateChannel
- generate
Channel(topic): NotificationChannel Default StreamingHTTPChanel2023 for a topic. -Currently channel description is only used internally and never sent to the client. -The default channel uses Turtle.
-Parameters
- topic: ResourceIdentifier
Returns NotificationChannel
Function generateHttpErrorClass
- generate
Http Error Class<TCode>(statusCode, name): HttpErrorClass<TCode> Generates a new HttpError class with the given status code and name. -In general, status codes are used to uniquely identify error types, -so there should be no 2 classes with the same value there.
-To make sure Components.js can work with these newly generated classes, -the generated class should be called
-BaseHttpErroras that name is an entry in.componentsignore. -The actual class should then extendBaseHttpErrorand have a correct constructor, -so the Components.js generator can generate the correct components JSON-LD file during build.Type Parameters
Parameters
- statusCode: TCode
- name: string
Returns HttpErrorClass<TCode>
Function generateRedirectHttpErrorClass
- generate
Redirect Http Error Class<TCode>(code, name): RedirectHttpErrorClass<TCode> Generates a RedirectHttpErrorClass, similar to how generateHttpErrorClass works. -The difference is that here a
-locationfield also gets set and thegetInstancemethod -also uses the RedirectHttpError.isInstance function.Type Parameters
Parameters
- code: TCode
- name: string
Returns RedirectHttpErrorClass<TCode>
Function getAccessControlResource
Function getBestPreference
- get
Best Preference(types, preferred): ValuePreference | undefined Finds the type from the given types that has the best match with the given preferences, -based on the calculated weight.
-Parameters
- types: ValuePreferences
Types for which we want to find the best match.
- - preferred: ValuePreferences
Preferences to match the types against.
-
Returns ValuePreference | undefined
A ValuePreference containing the best match and the corresponding weight. -Undefined if there is no match.
-- types: ValuePreferences
Function getConversionTarget
- get
Conversion Target(types, preferred?): string | undefined For a media type converter that can generate the given types, -this function tries to find the type that best matches the given preferences.
-This function combines several other conversion utility functions -to determine what output a converter should generate: -it cleans the preferences with cleanPreferences to support empty preferences -and to prevent the accidental generation of internal types, -after which the best match gets found based on the weights.
-Parameters
- types: ValuePreferences
Media types that can be converted to.
- - preferred: ValuePreferences = {}
Preferences for output type.
-
Returns string | undefined
The best match. Undefined if there is no match.
-- types: ValuePreferences
Function getDefault
- get
Default<TKey, TValue>(map, key, defaultFn): TValue Finds the result of calling
-map.get(key). -If there is no result, it instead returns the result of the default function. -The Map will also be updated to assign that default value to the given key.Type Parameters
Parameters
Returns TValue
- get
Default<TKey, TValue>(map, key, defaultFn): Promise<TValue> Finds the result of calling
-map.get(key). -If there is no result, it instead returns the result of the default function. -The Map will also be updated to assign the resolved default value to the given key.Type Parameters
Parameters
Returns Promise<TValue>
Function getLoggerFor
- get
Logger For(loggable): Logger Gets a logger instance for the given class instance.
-The following shows a typical pattern on how to create loggers:
-
- -class MyClass {
protected readonly logger = getLoggerFor(this);
} -If no class is applicable, a logger can also be created as follows:
-
- -const logger = getLoggerFor('MyFunction'); -Parameters
- loggable: string | Instance
A class instance or a class string name.
-
Returns Logger
- loggable: string | Instance
Function getRelativeUrl
- get
Relative Url(baseUrl, request, targetExtractor): Promise<string> Creates a relative URL by removing the base URL. -Will throw an error in case the resulting target is not withing the base URL scope.
-Parameters
- baseUrl: string
Base URL.
- - request: HttpRequest
Incoming request of which the target needs to be extracted.
- - targetExtractor: TargetExtractor
Will extract the target from the request.
-
Returns Promise<string>
- baseUrl: string
Function getSingleItem
Function getTemplateFilePath
- get
Template File Path(template?): string | undefined Returns the absolute path to the template. -Returns undefined if the input does not contain a file path.
-Parameters
Optionaltemplate: Template
Returns string | undefined
Function getTypeWeight
- get
Type Weight(type, preferred): number Tries to match the given type to the given preferences. -In case there are multiple matches the most specific one will be chosen as per RFC 7231.
-Parameters
- type: string
Type for which the matching weight is needed.
- - preferred: ValuePreferences
Preferences to match the type to.
-
Returns number
The corresponding weight from the preferences or 0 if there is no match.
-- type: string
Function getWeightedPreferences
- get
Weighted Preferences(types, preferred): ValuePreference[] Measures the weights for all the given types when matched against the given preferences. -Results will be sorted by weight. -Weights of 0 indicate that no match is possible.
-Parameters
- types: ValuePreferences
Types for which we want to calculate the weights.
- - preferred: ValuePreferences
Preferences to match the types against.
-
Returns ValuePreference[]
An array with a ValuePreference object for every input type, sorted by calculated weight.
-- types: ValuePreferences
Function guardStream
- guard
Stream<T>(stream): Guarded<T> Makes sure that listeners always receive the error event of a stream, -even if it was thrown before the listener was attached.
-When guarding a stream it is assumed that error listeners already attached should be ignored, -only error listeners attached after the stream is guarded will prevent an error from being logged.
-If the input is already guarded the guard will be reset, -which means ignoring error listeners already attached.
-Type Parameters
Parameters
- stream: T
Stream that can potentially throw an error.
-
Returns Guarded<T>
The stream.
-- stream: T
Function guardedStreamFrom
- guarded
Stream From(contents, options?): Guarded<Readable> Converts a string or array to a stream and applies an error guard so that it is Guarded.
-Parameters
- contents: string | Iterable<unknown>
Data to stream.
- Optionaloptions: ReadableOptionsOptions to pass to the Readable constructor. See Readable.from.
-
Returns Guarded<Readable>
- contents: string | Iterable<unknown>
Function hasScheme
- has
Scheme(url, ...schemes): boolean Checks if the scheme part of the specified url matches at least one of the provided options.
-Parameters
- url: string
A string representing the URL.
- Rest...schemes: string[]Scheme value options (the function will check whether at least one matches the URL scheme).
-
Returns boolean
True if the URL scheme matches at least one of the provided options, false otherwise.
-- url: string
Function identifierHashFn
- identifier
Hash Fn(identifier): string Converts a ResourceIdentifier into a string unique to that identifier.
-Parameters
- identifier: ResourceIdentifier
Returns string
Function importOidcProvider
- import
Oidc Provider(): CanBePromise<__module> Import the OIDC-provider package.
-As oidc-provider is an ESM package and CSS is CJS, we have to use a dynamic import here. -Unfortunately, there is a Node/Jest bug that causes segmentation faults when doing such an import in Jest: -https://github.com/nodejs/node/issues/35889 -To work around that, we do the import differently, in case we are in a Jest test run. -This can be detected via the env variables: https://jestjs.io/docs/environment-variables. -There have been reports of
-JEST_WORKER_IDbeing undefined, so to be sure we check both.Returns CanBePromise<__module>
Function isContainerIdentifier
- is
Container Identifier(identifier): boolean Checks whether the identifier corresponds to a container identifier.
-Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
- identifier: ResourceIdentifier
Function isHttpRequest
- is
Http Request(stream): stream is HttpRequest Checks if the given stream is an HttpRequest.
-Parameters
- stream: unknown
Returns stream is HttpRequest
Function isInternalContentType
Function isPromise
- is
Promise<T>(object): object is Promise<T> Verifies if the given value is a Promise or not.
-Type Parameters
Parameters
- object: PromiseOrValue<T>
Object to check.
-
Returns object is Promise<T>
- object: PromiseOrValue<T>
Function isRepresentationMetadata
- is
Representation Metadata(object): object is RepresentationMetadata Determines whether the object is a
-RepresentationMetadata.Parameters
- object: unknown
Returns object is RepresentationMetadata
Function isResourceIdentifier
- is
Resource Identifier(object): object is ResourceIdentifier Determines whether the object is a ResourceIdentifier.
-Parameters
- object: unknown
Returns object is ResourceIdentifier
Function isSystemError
- is
System Error(error): error is SystemError Parameters
- error: unknown
Returns error is SystemError
Function isWebSocket2023Channel
- is
Web Socket2023 Channel(channel): channel is WebSocketChannel2023 Parameters
- channel: NotificationChannel
Returns channel is WebSocketChannel2023
Function isWebhook2023Channel
- is
Webhook2023 Channel(channel): channel is WebhookChannel2023 Parameters
- channel: NotificationChannel
Returns channel is WebhookChannel2023
Function joinUrl
Concatenates all the given strings into a normalized URL. -Will place slashes between input strings if necessary.
-- join
Url(...parts): string Join all arguments together and normalize the resulting url. -This works similar to
-path.joinbut you shouldn't usepath.joinfor urls since it works -differently depending on the operating system and also doesn't work for some cases.Parameters
Rest...parts: string[]
Returns string
- join
Url(parts): string Parameters
- parts: string[]
Returns string
Function listSingleThreadedComponents
- list
Single Threaded Components<T>(componentsManager): Promise<string[]> Will list class names of components instantiated implementing the SingleThreaded -interface while the application is being run in multithreaded mode.
-Type Parameters
Parameters
- componentsManager: ComponentsManager<T>
The componentsManager being used to set up the application
-
Returns Promise<string[]>
- componentsManager: ComponentsManager<T>
Function map
- map<TIn, TOut>(iterable, callbackFn, thisArg?): Iterable<TOut>
Creates a new iterable with the results of calling a provided function on every element in the calling array. -Similar to the Array.prototype.map function. -See the documentation of the above function for more details.
-Type Parameters
Parameters
Returns Iterable<TOut>
Function matchesAuthorizationScheme
- matches
Authorization Scheme(scheme, authorization?): boolean Checks if the value of an HTTP Authorization header matches a specific scheme (e.g. Basic, Bearer, etc).
-Parameters
- scheme: string
Name of the authorization scheme (case insensitive).
- Optionalauthorization: stringThe value of the Authorization header (may be undefined).
-
Returns boolean
True if the Authorization header uses the specified scheme, false otherwise.
-- scheme: string
Function matchesMediaPreferences
- matches
Media Preferences(type, preferred?): boolean Checks if the given type matches the given preferences.
-Parameters
- type: string
Type to match.
- Optionalpreferred: ValuePreferencesPreferences to match against.
-
Returns boolean
- type: string
Function matchesMediaType
Function modify
- modify<T>(map, options): T
Modifies a SetMultiMap in place by removing and adding the requested entries. -Removals happen before additions.
-Type Parameters
- T extends SetMultiMap<any, any>
Parameters
- map: T
Map to start from.
- - options: ModifyOptions<T>
ModifyOptions describing the necessary changes.
-
Returns T
Function parseAccept
- parse
Accept(input, strict?): Accept[] Parses an Accept header string.
-Parameters
- input: string
The Accept header string.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns Accept[]
An array of Accept objects, sorted by weight. Accept parts -with invalid syntax are ignored and removed from the returned array.
-- input: string
Function parseAcceptCharset
- parse
Accept Charset(input, strict?): AcceptCharset[] Parses an Accept-Charset header string.
-Parameters
- input: string
The Accept-Charset header string.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns AcceptCharset[]
An array of AcceptCharset objects, sorted by weight. Invalid ranges -are ignored and not returned.
-- input: string
Function parseAcceptDateTime
- parse
Accept Date Time(input, strict?): AcceptDatetime[] Parses an Accept-DateTime header string.
-Parameters
- input: string
The Accept-DateTime header string.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns AcceptDatetime[]
An array with a single AcceptDatetime object, -or an empty array if a range in an invalid format is detected.
-- input: string
Function parseAcceptEncoding
- parse
Accept Encoding(input, strict?): AcceptEncoding[] Parses an Accept-Encoding header string.
-Parameters
- input: string
The Accept-Encoding header string.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns AcceptEncoding[]
An array of AcceptEncoding objects, sorted by weight. Invalid ranges -are ignored and not returned.
-- input: string
Function parseAcceptLanguage
- parse
Accept Language(input, strict?): AcceptLanguage[] Parses an Accept-Language header string.
-Parameters
- input: string
The Accept-Language header string.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns AcceptLanguage[]
An array of AcceptLanguage objects, sorted by weight. Invalid ranges -are ignored and not returned.
-- input: string
Function parseContentType
Function parseLinkHeader
Function parseParameters
- parse
Parameters(parameters, replacements, strict?): {
name: string;
value: string;
}[] Parses a list of split parameters and checks their validity. Parameters with invalid -syntax are ignored and not returned.
-Parameters
- parameters: string[]
A list of split parameters (token [ "=" ( token / quoted-string ) ])
- - replacements: Record<string, string>
The double quoted strings that need to be replaced.
- - strict: boolean = false
Determines if invalid values throw errors (
-true) or log warnings (false). Defaults tofalse.
Returns {
name: string;
value: string;
}[]An array of name/value objects corresponding to the parameters.
-- parameters: string[]
Function parsePath
- parse
Path<T>(route, path): NonNullable<ReturnType<T["matchPath"]>> Parses the given path with the given InteractionRoute. -This assumes this call will succeed and thus expects the path to have the correct format. -If not, a 500 error will be thrown.
-Type Parameters
- T extends InteractionRoute<string>
Parameters
- route: T
Route to parse with.
- - path: string
Path to parse.
-
Returns NonNullable<ReturnType<T["matchPath"]>>
Function parseQuads
- parse
Quads(readable, options?): Promise<Quad[]> Helper function to convert a Readable into an array of quads.
-Parameters
- readable: Guarded<Readable>
The readable object.
- - options: ParserOptions = {}
Options for the parser.
-
Returns Promise<Quad[]>
A promise containing the array of quads.
-- readable: Guarded<Readable>
Function pipeSafely
- pipe
Safely<T>(readable, destination, mapError?): Guarded<T> Pipes one stream into another and emits errors of the first stream with the second. -If the first stream errors, the second one will be destroyed with the given error. -This will also make the stream Guarded.
-Type Parameters
Parameters
- readable: ReadableStream
Initial readable stream.
- - destination: T
The destination for writing data.
- OptionalmapError: ((error: Error) => Error)Optional function that takes the error and converts it to a new error.
-- (error): Error
Parameters
- error: Error
Returns Error
Returns Guarded<T>
The destination stream.
-- readable: ReadableStream
Function preferencesToString
- preferences
To String(preferences): string Serializes a preferences object to a string for display purposes.
-Parameters
- preferences: ValuePreferences
Preferences to serialize
-
Returns string
- preferences: ValuePreferences
Function promiseSome
Function readTemplate
- read
Template(template?): Promise<string> Reads the template and returns it as a string.
-Parameters
Optionaltemplate: Template
Returns Promise<string>
Function reduce
- reduce<TIn>(iterable, callbackFn): TIn
Similar to the Array.prototype.reduce function, but for an iterable. -See the documentation of the above function for more details. -The first element will be used as the initial value.
-Type Parameters
Parameters
Returns TIn
- reduce<TIn, TOut>(iterable, callbackFn, initialValue): TOut
Similar to the Array.prototype.reduce function, but for an iterable. -See the documentation of the above function for more details.
-Type Parameters
Parameters
Returns TOut
Function resetInternalLoggerFactory
- reset
Internal Logger Factory(factory?): void Resets the internal logger factory, which holds the global logger factory. -For testing purposes only.
-Parameters
- factory: LazyLoggerFactory = ...
Returns void
Function resolveAssetPath
Function resolvePromiseOrValue
- resolve
Promise Or Value<TIn, TOut>(object, callback): PromiseOrValue<TOut> Calls
-callbackwith the resolved value ofobject. -In caseobjectis a Promise, the result will also be a Promise, -otherwise the result will be sync.Type Parameters
Parameters
Returns PromiseOrValue<TOut>
Function responseToDataset
- response
To Dataset(response, converter, body?): Promise<Representation> Converts a given Response (from a request that was already made) to an RDF dataset. -In case the given Response object was already parsed its body can be passed along as a string.
-The converter will be used to convert the response body to RDF.
-Response will be a Representation with content-type internal/quads.
-Parameters
- response: Response
- converter: RepresentationConverter
Optionalbody: string
Returns Promise<Representation>
Function serializeQuads
Function setGlobalLoggerFactory
- set
Global Logger Factory(loggerFactory): void Sets the global logger factory. -This causes loggers created by getLoggerFor to delegate to a logger from the given factory.
-Parameters
- loggerFactory: LoggerFactory
A logger factory.
-
Returns void
- loggerFactory: LoggerFactory
Function setSafeInterval
- set
Safe Interval<TArgs>(logger, message, callback, ms?, ...args): NodeJS.Timeout Wraps the callback for setInterval so errors get caught and logged. -Parameters are identical to the setInterval parameters starting from the 3rd argument. -The logger and message will be used when the callback throws an error. -Supports asynchronous callback functions.
-Type Parameters
Parameters
Returns NodeJS.Timeout
Function toCanonicalUriPath
- to
Canonical Uri Path(path): string Converts a URI path to the canonical version by splitting on slashes, -decoding any percent-based encodings, and then encoding any special characters. -This function is used to clean unwanted characters in the components of -the provided path.
-Parameters
- path: string
The path to convert to its canonical URI path form.
-
Returns string
The canonical URI path form of the provided path.
-- path: string
Function toComponentsJsType
- to
Components Js Type<T>(componentsManager, interfaceName): Promise<string> Convert an exported interface name to the properly expected Components.js type URI.
-Type Parameters
Parameters
- componentsManager: ComponentsManager<T>
The currently used ComponentsManager
- - interfaceName: string
An interface name
-
Returns Promise<string>
A Components.js type URI
-- componentsManager: ComponentsManager<T>
Function toNamedTerm
- to
Named Term(subject): NamedNode Converts a string to a named node when needed.
-Parameters
- subject: string
Subject to potentially transform.
-
Returns NamedNode
- subject: string
- to
Named Term<T>(subject): T Type Parameters
Parameters
- subject: T
Returns T
- to
Named Term<T>(subject): T | NamedNode Type Parameters
Parameters
- subject: string | T
Returns T | NamedNode
Function toObjectTerm
- to
Object Term(object, preferLiteral?): NamedNode Converts an object term when needed.
-Parameters
- object: string
Object to potentially transform.
- OptionalpreferLiteral: booleanWhether strings are converted to literals or named nodes.
-
Returns NamedNode
- object: string
- to
Object Term<T>(object, preferLiteral?): T Type Parameters
Parameters
- object: T
OptionalpreferLiteral: boolean
Returns T
- to
Object Term<T>(object, preferLiteral?): T | NamedNode Type Parameters
Parameters
- object: string | T
OptionalpreferLiteral: boolean
Returns T | NamedNode
Function toPredicateTerm
- to
Predicate Term(subject): NamedNode Converts a string to a named node when needed.
-Parameters
- subject: string
Subject to potentially transform.
-
Returns NamedNode
- subject: string
- to
Predicate Term<T>(subject): T Type Parameters
Parameters
- subject: T
Returns T
- to
Predicate Term<T>(subject): T | NamedNode Type Parameters
Parameters
- subject: string | T
Returns T | NamedNode
Function transformQuotedStrings
- transform
Quoted Strings(input): {
replacements: Record<string, string>;
result: string;
} Replaces all double quoted strings in the input string with
-"0","1", etc.Parameters
- input: string
The Accept header string.
-
Returns {
replacements: Record<string, string>;
result: string;
}The transformed string and a map with keys
-"0", etc. and values the original string that was there.replacements: Record<string, string>
result: string
- input: string
Function transformSafely
- transform
Safely<T>(source, options?): Guarded<Transform> Transforms a stream, ensuring that all errors are forwarded.
-Type Parameters
Parameters
- source: ReadableStream
The stream to be transformed.
- - options: AsyncTransformOptions<T> = {}
The transformation options.
-
Returns Guarded<Transform>
The transformed stream
-- source: ReadableStream
Function updateModifiedDate
- update
Modified Date(metadata, date?): void Updates the dc:modified time to the given time.
-Parameters
- metadata: RepresentationMetadata
Metadata to update.
- - date: Date = ...
Last modified date. Defaults to current time.
-
Returns void
- metadata: RepresentationMetadata
Function validateWithError
- validate
With Error<T>(schema, data, options?): Promise<T["__outputType"]> Same functionality as the yup validate function, but throws a BadRequestHttpError if there is an error.
-Type Parameters
Parameters
- schema: T
- data: unknown
Optionaloptions: ValidateOptions<AnyObject>
Returns Promise<T["__outputType"]>
Function verifyAccountId
- verify
Account Id(input?, expected?): asserts expected is string Asserts that the two given IDs are identical. -To be used when a request tries to access a resource to ensure they're not accessing someone else's data.
-Parameters
Optionalinput: stringInput ID.
-Optionalexpected: stringExpected ID.
-
Returns asserts expected is string
Community Solid Server - v7.1.0
Class Hierarchy
- AsyncHandler
- WaterfallHandler
- CredentialsExtractor
- AccessChecker
- ModesExtractor
- Authorizer
- PermissionReader
- MetadataGenerator
- Validator
- BodyParser
- ConditionsParser
- TargetExtractor
- MetadataParser
- PreferenceParser
- RequestParser
- OperationHandler
- ErrorHandler
- MetadataWriter
- AllowAcceptHeaderWriter
- AuxiliaryLinkMetadataWriter
- ConstantMetadataWriter
- ContentTypeMetadataWriter
- CookieMetadataWriter
- LinkRelMetadataWriter
- MappedMetadataWriter
- ModifiedMetadataWriter
- RangeMetadataWriter
- StorageDescriptionAdvertiser
- WacAllowMetadataWriter
- WwwAuthMetadataWriter
- OwnerMetadataWriter
- StreamingHttpMetadataWriter
- AllowAcceptHeaderWriter
- ResponseWriter
- PromptFactory
- EmailSender
- PodCreator
- InteractionHandler
- JsonInteractionHandler
- ClientCredentialsDetailsHandler
- CreateClientCredentialsHandler
- DeleteClientCredentialsHandler
- LogoutHandler
- ResolveLoginHandler
- CancelOidcHandler
- ClientInfoHandler
- ConsentHandler
- ForgetWebIdHandler
- PromptHandler
- PickWebIdHandler
- CreatePasswordHandler
- DeletePasswordHandler
- ForgotPasswordHandler
- ResetPasswordHandler
- UpdatePasswordHandler
- CreatePodHandler
- UpdateOwnerHandler
- InteractionRouteHandler
- LinkWebIdHandler
- UnlinkWebIdHandler
- ControlHandler
- CookieInteractionHandler
- LocationInteractionHandler
- StaticInteractionHandler
- VersionHandler
- ViewInteractionHandler
- ClientCredentialsDetailsHandler
- OwnershipValidator
- Finalizer
- CliExtractor
- ShorthandExtractor
- ShorthandResolver
- Initializer
- VariableHandler
- HttpHandler
- OperationHttpHandler
- ServerConfigurator
- WebSocketHandler
- StorageDescriber
- NotificationGenerator
- NotificationSerializer
- WebSocket2023Handler
- StreamingHttp2023Emitter
- NotificationEmitter
- NotificationHandler
- StateHandler
- BaseRouterHandler
- RepresentationConverter
- PatchHandler
- RdfStorePatcher
- RepresentationPatcher
- RouterRule
- BooleanHandler
- CachedHandler
- ConditionalHandler
- MethodFilterHandler
- ParallelHandler
- ProcessHandler
- SequenceHandler
- StaticHandler
- StaticThrowHandler
- UnionHandler
- UnsupportedAsyncHandler
- TemplateEngine
- WaterfallHandler
Community Solid Server - v7.1.0
Community Solid Server
![[Solid logo]](https://raw.githubusercontent.com/CommunitySolidServer/CommunitySolidServer/main/templates/images/solid.svg)
-
-
-
The Community Solid Server is open software -that provides you with a Solid Pod and identity. -This Pod acts as your own personal storage space -so you can share data with people and Solid applications.
-As an open and modular implementation of the -Solid specifications, -the Community Solid Server is a great companion:
--
-
-
-
🧑🏽 for people who want to try out having their own Pod
-
- -
-
👨🏿💻 for developers who want to quickly create and test Solid apps
-
- -
-
👩🏻🔬 for researchers who want to design new features for Solid
-
-
And, of course, for many others who like to experience Solid.
-⚡ Running the Community Solid Server
Make sure you have Node.js 18.0 or higher. -If this is your first time using Node.js, -you can find instructions on how to do this here.
-npx @solid/community-server
-Now visit your brand new server at http://localhost:3000/!
-To persist your pod's contents between restarts, use:
-npx @solid/community-server -c @css:config/file.json -f data/
-In case you prefer to use Docker instead, -you can find instructions for this and other methods in the -documentation.
-🔧 Configure your server
Substantial changes to server behavior can be achieved via JSON configuration files. -The Community Solid Server uses Components.js -to specify how modules and components need to be wired together at runtime.
-Recipes for configuring the server can be found at CommunitySolidServer/recipes.
-Examples and guidance on custom configurations
-are available in the config folder,
-and the configurations tutorial.
-There is also a configuration generator.
👩🏽💻 Developing server code
The server allows writing and plugging in custom modules -without altering its base source code.
-The 📗 API documentation and -the 📓 user documentation -can help you find your way. -There is also a repository of 📚 comprehensive tutorials
-📜 License
The Solid Community Server code -is copyrighted by Inrupt Inc. -and imec -and available under the MIT License.
-🎤 Feedback and questions
Don't hesitate to start a discussion -or report a bug.
-There's also a Matrix-based, CSS-focused chat
-Learn more about Solid at solidproject.org.
-Interface AccessCheckerArgs
acl: Store<Quad, Quad, Quad, Quad>;
credentials: Credentials;
rule: Term;
}
Index
Properties
Interface AccountInitializerArgs
accountStore: AccountStore;
email: string;
name?: string;
password: string;
passwordStore: PasswordStore;
podCreator: PodCreator;
}
Index
Properties
Properties
account
Creates the accounts.
-Email address for the account login.
-Optionalname
Name to use for the pod. If undefined the pod will be made in the root of the server.
-password
Password for the account login.
-password
Adds the login methods.
-pod
Creates the pods.
-Interface AccountStore
Used to store account data.
-create: (() => Promise<string>);
getSetting: (<T>(id: string, setting: T) => Promise<AccountSettings[T]>);
updateSetting: (<T>(id: string, setting: T, value: AccountSettings[T]) => Promise<void>);
}
Implemented by
Index
Properties
Properties
create
Creates a new and empty account. -Since this account will not yet have a login method, -implementations should restrict what is possible with this account, -and should potentially have something in place to clean these accounts up if they are unused.
-get
Finds the setting of the account with the given identifier.
-Type declaration
- <T>(id, setting): Promise<AccountSettings[T]>
Type Parameters
Parameters
- id: string
The account identifier.
- - setting: T
The setting to find the value of.
-
Returns Promise<AccountSettings[T]>
- id: string
update
Updates the settings for the account with the given identifier to the new values.
-Type declaration
- <T>(id, setting, value): Promise<void>
Type Parameters
Parameters
- id: string
The account identifier.
- - setting: T
The setting to update.
- - value: AccountSettings[T]
The new value for the setting.
-
Returns Promise<void>
- id: string
Interface AdapterFactory
A factory that generates an Adapter to be used by the IDP to persist information.
The oidc-provider library will call the relevant functions when it needs to find/create/delete metadata.
-For a full explanation of how these functions work and what is expected,
-have a look at https://github.com/panva/node-oidc-provider/blob/main/example/my_adapter.js
Implemented by
Index
Properties
Interface AlgJwk
A JWK where the alg parameter is always defined.
alg: AsymmetricSigningAlgorithm;
crv?: string;
d?: string;
dp?: string;
dq?: string;
e?: string;
ext?: boolean;
k?: string;
key_ops?: string[];
kid?: string;
kty?: string;
n?: string;
oth?: {
d?: string;
r?: string;
t?: string;
}[];
p?: string;
q?: string;
qi?: string;
use?: string;
x?: string;
x5c?: string[];
x5t?: string;
x5t#S256?: string;
x5u?: string;
y?: string;
}
Hierarchy
- JWK
- AlgJwk
Properties
alg
JWK "alg" (Algorithm) Parameter.
-Optionalcrv
Optionald
Optionaldp
Optionaldq
Optionale
Optionalext
JWK "ext" (Extractable) Parameter.
-Optionalk
Optionalkey_
JWK "key_ops" (Key Operations) Parameter.
-Optionalkid
JWK "kid" (Key ID) Parameter.
-Optionalkty
JWK "kty" (Key Type) Parameter.
-Optionaln
Optionaloth
d?: string;
r?: string;
t?: string;
}[]
Optionalp
Optionalq
Optionalqi
Optionaluse
JWK "use" (Public Key Use) Parameter.
-Optionalx
Optionalx5c
JWK "x5c" (X.509 Certificate Chain) Parameter.
-Optionalx5t
JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter.
-Optionalx5t#
"x5t#S256" (X.509 Certificate SHA-256 Thumbprint) Parameter.
-Optionalx5u
JWK "x5u" (X.509 URL) Parameter.
-Optionaly
Interface AppRunnerInput
Parameters that can be used to instantiate the server through code.
-argv?: string[];
config?: string | string[];
loaderProperties?: Partial<IComponentsManagerBuilderOptions<App>>;
shorthand?: Shorthand;
variableBindings?: VariableBindings;
}
Index
Properties
Properties
Optionalargv
An array containing CLI arguments passed to start the process. -Entries here have the lowest priority for assigning values to variables.
-Optionalconfig
Path to the server config file(s). Defaults to @css:config/default.json.
Optionalloader
Properties that will be used when building the Components.js manager. -Default values:
--
-
typeChecking:false, as the server components would otherwise error.
-mainModulePath:@css:, which resolves to the directory of the CSS package. -This is useful for packages that depend on the CSS -but do not create any new modules themselves.
-
Optionalshorthand
CLI argument names and their corresponding values.
-E.g.: { rootFilePath: '.data' }.
-Abbreviated parameter names can not be used, so { f: '.data' } would not work.
In case both shorthand and variableBindings have entries that would result in a value for the same variable,
-variableBindings has priority.
Optionalvariable
Values to apply to the Components.js variables.
-These are the variables CLI values will be converted to.
-The keys should be the variable URIs.
-E.g.: { 'urn:solid-server:default:variable:rootFilePath': '.data' }.
Interface AsyncTransformOptions<T>
allowHalfOpen?: boolean;
autoDestroy?: boolean;
decodeStrings?: boolean;
defaultEncoding?: BufferEncoding;
emitClose?: boolean;
encoding?: BufferEncoding;
flush?: ((this: Transform) => unknown);
highWaterMark?: number;
objectMode?: boolean;
readableHighWaterMark?: number;
readableObjectMode?: boolean;
signal?: AbortSignal;
transform?: ((this: Transform, data: T, encoding: string) => unknown);
writableCorked?: number;
writableHighWaterMark?: number;
writableObjectMode?: boolean;
construct?(this: Duplex, callback: ((error?: null | Error) => void)): void;
destroy?(this: Duplex, error: null | Error, callback: ((error: null | Error) => void)): void;
final?(this: Duplex, callback: ((error?: null | Error) => void)): void;
read?(this: Duplex, size: number): void;
write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: ((error?: null | Error) => void)): void;
writev?(this: Duplex, chunks: {
chunk: any;
encoding: BufferEncoding;
}[], callback: ((error?: null | Error) => void)): void;
}
Type Parameters
Hierarchy
- DuplexOptions
- AsyncTransformOptions
Index
Properties
Methods
Properties
Optionalallow
Optionalauto
Optionaldecode
Optionaldefault
Optionalemit
Optionalencoding
Optionalflush
Performs any final actions after the source has ended
-Optionalhigh
Optionalobject
Optionalreadable
Optionalreadable
Optionalsignal
When provided the corresponding AbortController can be used to cancel an asynchronous action.
Optionaltransform
Transforms data from the source by calling the push method
Optionalwritable
Optionalwritable
Optionalwritable
Interface AtomicDataAccessor
The AtomicDataAccessor interface has identical function signatures as -the DataAccessor, with the additional constraint that every function call -must be atomic in its effect: either the call fully succeeds, reaching the -desired new state; or it fails, upon which the resulting state remains -identical to the one before the call.
-canHandle: ((representation: Representation) => Promise<void>);
deleteResource: ((identifier: ResourceIdentifier) => Promise<void>);
getChildren: ((identifier: ResourceIdentifier) => AsyncIterableIterator<RepresentationMetadata>);
getData: ((identifier: ResourceIdentifier) => Promise<Guarded<Readable>>);
getMetadata: ((identifier: ResourceIdentifier) => Promise<RepresentationMetadata>);
writeContainer: ((identifier: ResourceIdentifier, metadata: RepresentationMetadata) => Promise<void>);
writeDocument: ((identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata) => Promise<void>);
writeMetadata: ((identifier: ResourceIdentifier, metadata: RepresentationMetadata) => Promise<void>);
}
Hierarchy (view full)
- DataAccessor
- AtomicDataAccessor
Implemented by
Index
Properties
Properties
can
Should throw a NotImplementedHttpError if the DataAccessor does not support storing the given Representation.
-Type declaration
- (representation): Promise<void>
Parameters
- representation: Representation
Incoming Representation.
-
Returns Promise<void>
- representation: Representation
delete
Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Type declaration
- (identifier): Promise<void>
Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Type declaration
- (identifier): AsyncIterableIterator<RepresentationMetadata>
Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Type declaration
- (identifier): Promise<Guarded<Readable>>
Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
Returns the metadata corresponding to the identifier.
-If possible, it is suggested to add a posix:size triple to the metadata indicating the binary size.
-This is necessary for range requests.
Type declaration
- (identifier): Promise<RepresentationMetadata>
Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Type declaration
- (identifier, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Type declaration
- (identifier, data, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Type declaration
- (identifier, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Interface AtomicResourceStore
A ResourceStore of which all operations are atomic.
-addResource: ((container: ResourceIdentifier, representation: Representation, conditions?: Conditions) => Promise<ChangeMap>);
deleteResource: ((identifier: ResourceIdentifier, conditions?: Conditions) => Promise<ChangeMap>);
getRepresentation: ((identifier: ResourceIdentifier, preferences: RepresentationPreferences, conditions?: Conditions) => Promise<Representation>);
hasResource: ((identifier: ResourceIdentifier) => Promise<boolean>);
modifyResource: ((identifier: ResourceIdentifier, patch: Patch, conditions?: Conditions) => Promise<ChangeMap>);
setRepresentation: ((identifier: ResourceIdentifier, representation: Representation, conditions?: Conditions) => Promise<ChangeMap>);
}
Hierarchy (view full)
- ResourceStore
- AtomicResourceStore
Implemented by
Index
Properties
Properties
add
Creates a new resource in the container.
-Type declaration
- (container, representation, conditions?): Promise<ChangeMap>
Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
Deletes a resource.
-Type declaration
- (identifier, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
Retrieves a representation of a resource.
-Type declaration
- (identifier, preferences, conditions?): Promise<Representation>
Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
Checks whether a resource exists in this ResourceSet.
-Type declaration
- (identifier): Promise<boolean>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Type declaration
- (identifier, patch, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Type declaration
- (identifier, representation, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Interface AuthorizerInput
availablePermissions: PermissionMap;
credentials: Credentials;
requestedModes: AccessMap;
}
Index
Properties
Interface AuthorizingHttpHandlerArgs
authorizer: Authorizer;
credentialsExtractor: CredentialsExtractor;
modesExtractor: ModesExtractor;
operationHandler: OperationHttpHandler;
permissionReader: PermissionReader;
}
Index
Properties
Properties
authorizer
Verifies if the requested operation is allowed.
-credentials
Extracts the credentials from the incoming request.
-modes
Extracts the required modes from the generated Operation.
-operation
Handler to call if the operation is authorized.
-permission
Reads the permissions available for the Operation.
-Interface AuxiliaryIdentifierStrategy
A strategy for handling auxiliary related ResourceIdentifiers.
-getAuxiliaryIdentifier: ((identifier: ResourceIdentifier) => ResourceIdentifier);
getAuxiliaryIdentifiers: ((identifier: ResourceIdentifier) => ResourceIdentifier[]);
getSubjectIdentifier: ((identifier: ResourceIdentifier) => ResourceIdentifier);
isAuxiliaryIdentifier: ((identifier: ResourceIdentifier) => boolean);
}
Hierarchy (view full)
- AuxiliaryIdentifierStrategy
Implemented by
Index
Properties
get
Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Type declaration
- (identifier): ResourceIdentifier
Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the corresponding auxiliary resource.
-- identifier: ResourceIdentifier
get
Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Type declaration
- (identifier): ResourceIdentifier[]
Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
get
Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Type declaration
- (identifier): ResourceIdentifier
Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Type declaration
- (identifier): boolean
Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
Interface AuxiliaryStrategy
A strategy for handling one or more types of auxiliary resources. -References to "an auxiliary resource" implicitly imply a specific type of auxiliary resources -supported by this strategy.
-addMetadata: ((metadata: RepresentationMetadata) => Promise<void>);
getAuxiliaryIdentifier: ((identifier: ResourceIdentifier) => ResourceIdentifier);
getAuxiliaryIdentifiers: ((identifier: ResourceIdentifier) => ResourceIdentifier[]);
getSubjectIdentifier: ((identifier: ResourceIdentifier) => ResourceIdentifier);
isAuxiliaryIdentifier: ((identifier: ResourceIdentifier) => boolean);
isRequiredInRoot: ((identifier: ResourceIdentifier) => boolean);
usesOwnAuthorization: ((identifier: ResourceIdentifier) => boolean);
validate: ((representation: Representation) => Promise<void>);
}
Hierarchy (view full)
- AuxiliaryIdentifierStrategy
- AuxiliaryStrategy
Implemented by
Properties
add
Adds metadata related to this auxiliary resource, -in case this is required for this type of auxiliary resource. -The metadata that is added depends on the given identifier being an auxiliary or subject resource: -the metadata will be used to link to the other one, and potentially add extra typing info.
-Used for: -Solid, §4.3.1: "For any defined auxiliary resource available for a given Solid resource, all representations of -that resource MUST include an HTTP Link header pointing to the location of each auxiliary resource." -https://solid.github.io/specification/protocol#auxiliary-resources-server
-The above is an example of how that metadata would only be added in case the input is the subject identifier.
-Type declaration
- (metadata): Promise<void>
Parameters
- metadata: RepresentationMetadata
Metadata to update.
-
Returns Promise<void>
- metadata: RepresentationMetadata
get
Returns the identifier of the auxiliary resource corresponding to the given resource. -This does not guarantee that this auxiliary resource exists.
-Should error if there are multiple results: see getAuxiliaryIdentifiers.
-Type declaration
- (identifier): ResourceIdentifier
Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the corresponding auxiliary resource.
-- identifier: ResourceIdentifier
get
Returns all the identifiers of corresponding auxiliary resources. -This can be used when there are potentially multiple results. -In the case of a single result this should be an array containing the result of getAuxiliaryIdentifier.
-Type declaration
- (identifier): ResourceIdentifier[]
Parameters
- identifier: ResourceIdentifier
The ResourceIdentifier of which we need the corresponding auxiliary resources.
-
Returns ResourceIdentifier[]
The ResourceIdentifiers of the corresponding auxiliary resources.
-- identifier: ResourceIdentifier
get
Returns the identifier of the resource which this auxiliary resource is referring to. -This does not guarantee that this resource exists.
-Type declaration
- (identifier): ResourceIdentifier
Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns ResourceIdentifier
The ResourceIdentifier of the subject resource.
-- identifier: ResourceIdentifier
is
Checks if the input identifier corresponds to an auxiliary resource. -This does not check if that auxiliary resource exists, -only if the identifier indicates that there could be an auxiliary resource there.
-Type declaration
- (identifier): boolean
Parameters
- identifier: ResourceIdentifier
Identifier to check.
-
Returns boolean
true if the input identifier points to an auxiliary resource.
-- identifier: ResourceIdentifier
is
Whether the root storage container requires this auxiliary resource to be present. -If yes, this means they can't be deleted individually from such a container.
-Type declaration
- (identifier): boolean
Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns boolean
- identifier: ResourceIdentifier
uses
Whether this auxiliary resources uses its own authorization instead of the subject resource authorization.
-Type declaration
- (identifier): boolean
Parameters
- identifier: ResourceIdentifier
Identifier of the auxiliary resource.
-
Returns boolean
- identifier: ResourceIdentifier
validate
Validates if the representation contains valid data for an auxiliary resource. -Should throw an error in case the data is invalid.
-Type declaration
- (representation): Promise<void>
Parameters
- representation: Representation
Representation of the auxiliary resource.
-
Returns Promise<void>
- representation: Representation
Interface BasePodCreatorArgs
baseUrl: string;
identifierGenerator: IdentifierGenerator;
podStore: PodStore;
relativeWebIdPath: string;
webIdStore: WebIdStore;
}
Index
Properties
Properties
base
Base URL of the server.
-Used to potentially set the solid:oidcIssuer triple
-and/or the pod URL if it is a root pod.
identifier
Generates the base URL of the pod based on the input name.
pod
Pod data store.
-relative
The path of where the WebID will be generated by the template, relative to the pod URL.
-web
WebID data store.
-Interface BaseRouterHandlerArgs<T>
allowedMethods?: string[];
allowedPathNames?: string[];
baseUrl?: string;
handler: T;
}
Type Parameters
- T extends AsyncHandler<unknown, unknown>
Hierarchy (view full)
- BaseRouterHandlerArgs
Index
Properties
Properties
Optionalallowed
The allowed method(s). * can be used to indicate all methods are allowed.
-Default is [ '*' ].
Optionalallowed
Regular expression(s) used to match the target URL.
-The base URl without trailing slash will be stripped of before applying the regular expressions,
-so the input will always start with a /.
-Default is [ '.*' ].
Optionalbase
The base URL of the server.
-Not required if no value is provided for allowedPathNames.
handler
The handler to call if all checks pass.
-Interface BaseServerFactoryOptions
Options to be used when creating the server.
-Due to Components.js not supporting external types, this has been simplified (for now?).
-The common https keys here (key/cert/pfx) will be interpreted as file paths that need to be read
-before passing the options to the createServer function.
cert?: string;
https?: boolean;
key?: string;
passphrase?: string;
pfx?: string;
}
Index
Properties
Interface BasicConditionsOptions
matchesETag?: string[];
modifiedSince?: Date;
notMatchesETag?: string[];
unmodifiedSince?: Date;
}
Index
Properties
Interface BasicRequestParserArgs
Input parsers required for a BasicRequestParser.
-bodyParser: BodyParser;
conditionsParser: ConditionsParser;
metadataParser: MetadataParser;
preferenceParser: PreferenceParser;
targetExtractor: TargetExtractor;
}
Index
Properties
Interface CliOptions
envVarPrefix?: string;
loadFromEnv?: boolean;
strictMode?: boolean;
usage?: string;
}
Index
Properties
Interface ClientCredentialsStore
Stores and creates ClientCredentials.
-create: ((label: string, webId: string, accountId: string) => Promise<ClientCredentials>);
delete: ((id: string) => Promise<void>);
findByAccount: ((accountId: string) => Promise<ClientCredentials[]>);
findByLabel: ((label: string) => Promise<undefined | ClientCredentials>);
get: ((id: string) => Promise<undefined | ClientCredentials>);
}
Implemented by
Index
Properties
Properties
create
Creates new token.
-Type declaration
- (label, webId, accountId): Promise<ClientCredentials>
Parameters
- label: string
Identifier to use for the new token.
- - webId: string
WebID to identify as when using this token.
- - accountId: string
Returns Promise<ClientCredentials>
- label: string
delete
Deletes the token with the given ID.
-Type declaration
- (id): Promise<void>
Parameters
- id: string
ID of the token.
-
Returns Promise<void>
- id: string
find
Find all tokens created by the given account.
-Type declaration
- (accountId): Promise<ClientCredentials[]>
Parameters
- accountId: string
ID of the account.
-
Returns Promise<ClientCredentials[]>
- accountId: string
find
Find the ClientCredentials with the given label.
-Type declaration
- (label): Promise<undefined | ClientCredentials>
Parameters
- label: string
Label of the token.
-
Returns Promise<undefined | ClientCredentials>
- label: string
get
Find the ClientCredentials with the given ID.
-Type declaration
- (id): Promise<undefined | ClientCredentials>
Parameters
- id: string
ID of the token.
-
Returns Promise<undefined | ClientCredentials>
- id: string
Interface ComponentsJsFactory
Used for instantiating new object using Components.js configurations.
-generate: (<T>(configPath: string, componentIri: string, variables: Record<string, unknown>) => Promise<T>);
}
Implemented by
Index
Properties
Properties
generate
Instantiates a new object using Components.js.
-Type declaration
- <T>(configPath, componentIri, variables): Promise<T>
Type Parameters
Parameters
- configPath: string
Location of the config to instantiate.
- - componentIri: string
IRI of the object in the config that will be the result.
- - variables: Record<string, unknown>
Variables to send to Components.js
-
Returns Promise<T>
The resulting object, corresponding to the given component IRI.
-- configPath: string
Interface ComposedNotificationHandlerArgs
eTagHandler: ETagHandler;
emitter: NotificationEmitter;
generator: NotificationGenerator;
serializer: NotificationSerializer;
}
Index
Properties
Interface Conditions
The conditions of an HTTP conditional request.
-matchesETag?: string[];
matchesMetadata: ((metadata?: RepresentationMetadata, strict?: boolean) => boolean);
modifiedSince?: Date;
notMatchesETag?: string[];
unmodifiedSince?: Date;
}
Implemented by
Index
Properties
Properties
OptionalmatchesETag
Valid if matching any of the given ETags.
-matches
Checks validity based on the given metadata.
-Type declaration
- (metadata?, strict?): boolean
Parameters
Optionalmetadata: RepresentationMetadataMetadata of the representation. Undefined if the resource does not exist.
-Optionalstrict: booleanHow to compare the ETag related headers. -If true, the comparison will happen on representation level. -If false, the comparison happens on resource level, ignoring the content-type.
-
Returns boolean
Optionalmodified
Valid if modified since the given date.
-Optionalnot
Valid if not matching any of the given ETags.
-Optionalunmodified
Valid if not modified since the given date.
-Interface ConstantConverterOptions
Extra options for the ConstantConverter.
-container?: boolean;
disabledMediaRanges?: string[];
document?: boolean;
enabledMediaRanges?: string[];
minQuality?: number;
}
Index
Properties
Properties
Optionalcontainer
Whether this should trigger on containers.
-Optionaldisabled
Media ranges for which the conversion should not happen.
-Optionaldocument
Whether this should trigger on documents.
-Optionalenabled
Media ranges for which the conversion should happen.
-Optionalmin
The minimum requested quality/preference before this should trigger.
-Interface ContainerInitializerArgs
baseUrl: string;
generator: ResourcesGenerator;
path: string;
storage: KeyValueStorage<string, boolean>;
storageKey: string;
store: ResourceStore;
}
Properties
base
Base URL of the server.
-generator
Generator that should be used to generate container contents.
-path
Relative path of the container.
-storage
Used to store initialization status.
-storage
Key that is used to store the boolean in the storage indicating the container is initialized.
-store
ResourceStore where the container should be stored.
-Interface CookieStore
Used to generate and store cookies.
-delete: ((cookie: string) => Promise<boolean>);
generate: ((accountId: string) => Promise<string>);
get: ((cookie: string) => Promise<undefined | string>);
refresh: ((cookie: string) => Promise<undefined | Date>);
}
Implemented by
Properties
delete
Deletes the given cookie.
-Type declaration
- (cookie): Promise<boolean>
Parameters
- cookie: string
Cookie to delete.
-
Returns Promise<boolean>
- cookie: string
generate
Generates and stores a new cookie for the given accountId. -This does not replace previously generated cookies.
-Type declaration
- (accountId): Promise<string>
Parameters
- accountId: string
Account to create a cookie for.
-
Returns Promise<string>
The generated cookie.
-- accountId: string
get
Return the accountID associated with the given cookie.
-Type declaration
- (cookie): Promise<undefined | string>
Parameters
- cookie: string
Cookie to find the account for.
-
Returns Promise<undefined | string>
- cookie: string
refresh
Refreshes the cookie expiration and returns when it will expire if the cookie exists.
-Type declaration
- (cookie): Promise<undefined | Date>
Parameters
- cookie: string
Cookie to refresh.
-
Returns Promise<undefined | Date>
- cookie: string
Interface DataAccessor
A DataAccessor is the building block closest to the actual data storage. -It should not worry about most Solid logic, most of that will be handled before it is called. -There are a few things it still needs to do, and it is very important every implementation does this:
--
-
- If the input identifier ends with a slash, it should be assumed the identifier is targeting a container. -
- Similarly, if there is no trailing slash it should assume a document. -
- It should always throw a NotFoundHttpError if it does not have data matching the input identifier. -
- DataAccessors should not generate containment triples. This will be done externally using
getChildren.
-
canHandle: ((representation: Representation) => Promise<void>);
deleteResource: ((identifier: ResourceIdentifier) => Promise<void>);
getChildren: ((identifier: ResourceIdentifier) => AsyncIterableIterator<RepresentationMetadata>);
getData: ((identifier: ResourceIdentifier) => Promise<Guarded<Readable>>);
getMetadata: ((identifier: ResourceIdentifier) => Promise<RepresentationMetadata>);
writeContainer: ((identifier: ResourceIdentifier, metadata: RepresentationMetadata) => Promise<void>);
writeDocument: ((identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata) => Promise<void>);
writeMetadata: ((identifier: ResourceIdentifier, metadata: RepresentationMetadata) => Promise<void>);
}
Hierarchy (view full)
- DataAccessor
Implemented by
Index
Properties
Properties
can
Should throw a NotImplementedHttpError if the DataAccessor does not support storing the given Representation.
-Type declaration
- (representation): Promise<void>
Parameters
- representation: Representation
Incoming Representation.
-
Returns Promise<void>
- representation: Representation
delete
Deletes the resource and its corresponding metadata.
-Solid, §5.4: "When a contained resource is deleted, the server MUST also remove the corresponding containment -triple, which has the effect of removing the deleted resource from the containing container." -https://solid.github.io/specification/protocol#deleting-resources
-Type declaration
- (identifier): Promise<void>
Parameters
- identifier: ResourceIdentifier
Resource to delete.
-
Returns Promise<void>
- identifier: ResourceIdentifier
get
Returns metadata for all resources in the requested container. -This should not be all metadata of those resources (but it can be), -but instead the main metadata you want to show in situations -where all these resources are presented simultaneously. -Generally this would be metadata that is present for all of these resources, -such as resource type or last modified date.
-It can be safely assumed that the incoming identifier will always correspond to a container.
-Type declaration
- (identifier): AsyncIterableIterator<RepresentationMetadata>
Parameters
- identifier: ResourceIdentifier
Identifier of the parent container.
-
Returns AsyncIterableIterator<RepresentationMetadata>
- identifier: ResourceIdentifier
get
Returns a data stream stored for the given identifier. -It can be assumed that the incoming identifier will always correspond to a document.
-Type declaration
- (identifier): Promise<Guarded<Readable>>
Parameters
- identifier: ResourceIdentifier
Identifier for which the data is requested.
-
Returns Promise<Guarded<Readable>>
- identifier: ResourceIdentifier
get
Returns the metadata corresponding to the identifier.
-If possible, it is suggested to add a posix:size triple to the metadata indicating the binary size.
-This is necessary for range requests.
Type declaration
- (identifier): Promise<RepresentationMetadata>
Parameters
- identifier: ResourceIdentifier
Identifier for which the metadata is requested.
-
Returns Promise<RepresentationMetadata>
- identifier: ResourceIdentifier
write
Writes metadata for a container. -If the container does not exist yet it should be created, -if it does its metadata should be overwritten, except for the containment triples.
-Type declaration
- (identifier, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the container.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
Writes data and metadata for a document. -If any data and/or metadata exist for the given identifier, it should be overwritten.
-Type declaration
- (identifier, data, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the resource.
- - data: Guarded<Readable>
Data to store.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
write
Writes metadata for a resource. -It can safely be assumed that the subject resource already exists.
-Type declaration
- (identifier, metadata): Promise<void>
Parameters
- identifier: ResourceIdentifier
Identifier of the subject resource.
- - metadata: RepresentationMetadata
Metadata to store.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Interface ETagHandler
Responsible for everything related to ETag generation and comparison. -ETags are constructed in such a way they can both be used for the standard ETag usage of comparing representations, -but also to see if two ETags of different representations correspond to the same resource state.
-getETag: ((metadata: RepresentationMetadata) => undefined | string);
matchesETag: ((metadata: RepresentationMetadata, eTag: string, strict: boolean) => boolean);
sameResourceState: ((eTag1: string, eTag2: string) => boolean);
}
Implemented by
Index
Properties
Properties
getETag
Generates an ETag for the given metadata. Returns undefined if no ETag could be generated.
-Type declaration
- (metadata): undefined | string
Parameters
- metadata: RepresentationMetadata
Metadata of the representation to generate an ETag for.
-
Returns undefined | string
- metadata: RepresentationMetadata
matchesETag
Validates whether the given metadata corresponds to the given ETag.
-Type declaration
- (metadata, eTag, strict): boolean
Parameters
- metadata: RepresentationMetadata
Metadata of the resource.
- - eTag: string
ETag to compare to.
- - strict: boolean
True if the comparison needs to be on representation level. -False if it is on resource level and the content-type doesn't matter.
-
Returns boolean
- metadata: RepresentationMetadata
same
Validates whether 2 ETags correspond to the same state of a resource, -independent of the representation the ETags correspond to.
-Type declaration
- (eTag1, eTag2): boolean
Parameters
- eTag1: string
First ETag to compare.
- - eTag2: string
Second ETag to compare.
-
Returns boolean
- eTag1: string
Interface EmailSenderArgs
emailConfig: {
auth: {
pass: string;
user: string;
};
host: string;
port: number;
};
senderName?: string;
}
Index
Properties
Interface ExpiringReadWriteLocker
A ReadWriteLocker where the locks expire after a given time.
-withReadLock: (<T>(identifier: ResourceIdentifier, whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)) => Promise<T>);
withWriteLock: (<T>(identifier: ResourceIdentifier, whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)) => Promise<T>);
}
Hierarchy (view full)
- ReadWriteLocker
- ExpiringReadWriteLocker
Implemented by
Index
Properties
Properties
with
As ReadWriteLocker.withReadLock but the locked function gets called with a maintainLock callback function
-to reset the lock expiration every time it is called.
-The resulting promise will reject once the lock expires.
Type declaration
- <T>(identifier, whileLocked): Promise<T>
Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
with
As ReadWriteLocker.withWriteLock but the locked function gets called with a maintainLock
-callback function to reset the lock expiration every time it is called.
-The resulting promise will reject once the lock expires.
Type declaration
- <T>(identifier, whileLocked): Promise<T>
Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: ((maintainLock: (() => void)) => PromiseOrValue<T>)
A function to execute while the resource is locked. -Receives a callback as input parameter to maintain the lock.
-- (maintainLock): PromiseOrValue<T>
Parameters
- maintainLock: (() => void)
- (): void
Returns void
Returns PromiseOrValue<T>
- maintainLock: (() => void)
Returns Promise<T>
- identifier: ResourceIdentifier
Interface ExpiringStorage<TKey, TValue>
A KeyValueStorage in which the values can expire. -Entries with no expiration date never expire.
-delete: ((key: TKey) => Promise<boolean>);
entries: (() => AsyncIterableIterator<[TKey, TValue]>);
get: ((key: TKey) => Promise<undefined | TValue>);
has: ((key: TKey) => Promise<boolean>);
set(key: TKey, value: TValue, expiration?: number): Promise<ExpiringStorage<TKey, TValue>>;
set(key: TKey, value: TValue, expires?: Date): Promise<ExpiringStorage<TKey, TValue>>;
}
Type Parameters
Hierarchy (view full)
- KeyValueStorage<TKey, TValue>
- ExpiringStorage
Implemented by
Properties
delete
Deletes the value stored for the given key.
-Type declaration
- (key): Promise<boolean>
Parameters
- key: TKey
Key to delete.
-
Returns Promise<boolean>
If there was a value to delete.
-- key: TKey
entries
An iterable of entries in the storage.
-get
Returns the value stored for the given identifier.
-undefined if no value is stored.
has
Checks whether there is a value stored for the given key.
- Methods
set
- set(key, value, expiration?): Promise<ExpiringStorage<TKey, TValue>>
Sets the value for the given key. -Should error if the data is already expired.
-Parameters
Returns Promise<ExpiringStorage<TKey, TValue>>
The storage.
-- set(key, value, expires?): Promise<ExpiringStorage<TKey, TValue>>
Sets the value for the given key. -Should error if the data is already expired.
-Parameters
Returns Promise<ExpiringStorage<TKey, TValue>>
The storage.
-
Interface FileIdentifierMapper
Supports mapping a file to an URL and back.
-mapFilePathToUrl: ((filePath: string, isContainer: boolean) => Promise<ResourceLink>);
mapUrlToFilePath: ((identifier: ResourceIdentifier, isMetadata: boolean, contentType?: string) => Promise<ResourceLink>);
}
Implemented by
Index
Properties
Properties
map
Maps the given file path to an URL and determines the content-type
-Type declaration
- (filePath, isContainer): Promise<ResourceLink>
Parameters
- filePath: string
The input file path.
- - isContainer: boolean
If the path corresponds to a file.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- filePath: string
map
Maps the given resource identifier / URL to a file path. -Determines the content-type, if no content-type was provided, by finding the corresponding file. -If there is no corresponding file, a file path will be generated. -For containers, the content-type input gets ignored.
-Type declaration
- (identifier, isMetadata, contentType?): Promise<ResourceLink>
Parameters
- identifier: ResourceIdentifier
The input identifier.
- - isMetadata: boolean
If we are mapping the metadata of the resource instead of its data.
- OptionalcontentType: stringThe (optional) content-type of the resource.
-
Returns Promise<ResourceLink>
A ResourceLink with all the necessary metadata.
-- identifier: ResourceIdentifier
Interface FileIdentifierMapperFactory<T>
Factory that can create FileIdentifierMappers so the base and rootFilePath can be set dynamically. -Specifically used when identifiers need to be generated for a new pod (since pod identifiers are generated).
-create: ((base: string, rootFilePath: string) => Promise<T>);
}
Type Parameters
- T extends FileIdentifierMapper = FileIdentifierMapper
Implemented by
Index
Properties
Interface Finalizable
Allows for cleaning up an object and stopping relevant loops when the application needs to be stopped. -Use this interface to add finalization logic to classes that already extend some other type. -NOTE: classes without an existing extends-relation should extend from Finalizer instead!
-Implemented by
Index
Properties
Interface ForgotPasswordHandlerArgs
emailSender: EmailSender;
forgotPasswordStore: ForgotPasswordStore;
passwordStore: PasswordStore;
resetRoute: InteractionRoute<never>;
templateEngine: TemplateEngine<{
resetLink: string;
}>;
}
Index
Properties
Properties
email
Sender to send the actual email.
-forgot
Store containing the forgot password records.
-password
Store containing the password login information.
-reset
Route used to generate the reset link for the user.
-template
Template engine that will be used to generate the email body.
-Interface ForgotPasswordStore
Responsible for storing the records that are used when a user forgets their password.
-delete: ((recordId: string) => Promise<boolean>);
generate: ((id: string) => Promise<string>);
get: ((recordId: string) => Promise<undefined | string>);
}
Implemented by
Properties
delete
Deletes the Forgot Password Confirmation Record.
-Type declaration
- (recordId): Promise<boolean>
Parameters
- recordId: string
The record id of the forgot password confirmation record.
-
Returns Promise<boolean>
- recordId: string
generate
Creates a Forgot Password Confirmation Record. This will be to remember that -a user has made a request to reset a password. Throws an error if the email doesn't -exist.
-Type declaration
- (id): Promise<string>
Parameters
- id: string
ID of the email/password login object.
-
Returns Promise<string>
The record id. This should be included in the reset password link.
-- id: string
get
Gets the email associated with the forgot password confirmation record -or undefined if it's not present.
-Type declaration
- (recordId): Promise<undefined | string>
Parameters
- recordId: string
The record id retrieved from the link.
-
Returns Promise<undefined | string>
The user's email.
-- recordId: string
Interface Forwarded
The Forwarded header from RFC7239
-Interface GenericEventEmitter<TEvent, TFunc>
A typed interface of EventEmitter.
-Use the & operator to combine multiple event/function pairs into a single event emitter.
-The result needs to be a type and not an interface because of https://github.com/microsoft/TypeScript/issues/16936.
Use the createGenericEventEmitterClass function to generate an event emitter class with the correct typings -in case EventEmitter needs to be extended.
-addListener: ((event: TEvent, listener: TFunc) => this);
emit: ((event: TEvent, ...args: Parameters<TFunc>) => boolean);
eventNames: (() => TEvent[]);
listenerCount: ((event: TEvent) => number);
listeners: ((event: TEvent) => TFunc[]);
off: ((event: TEvent, listener: TFunc) => this);
on: ((event: TEvent, listener: TFunc) => this);
once: ((event: TEvent, listener: TFunc) => this);
prependListener: ((event: TEvent, listener: TFunc) => this);
prependOnceListener: ((event: TEvent, listener: TFunc) => this);
rawListeners: ((event: TEvent) => TFunc[]);
removeAllListeners: ((event: TEvent) => this);
removeListener: ((event: TEvent, listener: TFunc) => this);
[captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
getMaxListeners(): number;
setMaxListeners(n: number): this;
}
Type Parameters
Hierarchy
- EventEmitter
- GenericEventEmitter
Index
Properties
Methods
Properties
add
Alias for emitter.on(eventName, listener).
emit
Synchronously calls each of the listeners registered for the event namedeventName, in the order they were registered, passing the supplied arguments
-to each.
Returns true if the event had listeners, false otherwise.
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
-event
Returns an array listing the events for which the emitter has registered
-listeners. The values in the array are strings or Symbols.
const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
-listener
Returns the number of listeners listening to the event named eventName.
If listener is provided, it will return how many times the listener
-is found in the list of the listeners of the event.
listeners
Returns a copy of the array of listeners for the event named eventName.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
-off
Alias for emitter.removeListener().
on
Adds the listener function to the end of the listeners array for the
-event named eventName. No checks are made to see if the listener has
-already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple
-times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. Theemitter.prependListener() method can be used as an alternative to add the
-event listener to the beginning of the listeners array.
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
-Type declaration
- (event, listener): this
Returns this
once
Adds a one-timelistener function for the event named eventName. The
-next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. Theemitter.prependOnceListener() method can be used as an alternative to add the
-event listener to the beginning of the listeners array.
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
-Type declaration
- (event, listener): this
Returns this
prepend
Adds the listener function to the beginning of the listeners array for the
-event named eventName. No checks are made to see if the listener has
-already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple
-times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
Type declaration
- (event, listener): this
Returns this
prepend
Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
-listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
-Returns a reference to the EventEmitter, so that calls can be chained.
Type declaration
- (event, listener): this
Returns this
raw
Returns a copy of the array of listeners for the event named eventName,
-including any wrappers (such as those created by .once()).
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
-remove
Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
-particularly when the EventEmitter instance was created by some other
-component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
remove
Removes the specified listener from the listener array for the event namedeventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
-removeListener() will remove, at most, one instance of a listener from the
-listener array. If any single listener has been added multiple times to the
-listener array for the specified eventName, then removeListener() must be
-called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
-time of emitting are called in order. This implies that anyremoveListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
-will not remove them fromemit() in progress. Subsequent events behave as expected.
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
-Because listeners are managed using an internal array, calling this will
-change the position indices of any listener registered after the listener
-being removed. This will not impact the order in which listeners are called,
-but it means that any copies of the listener array as returned by
-the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
-event (as in the example below), removeListener() will remove the most
-recently added instance. In the example the once('ping')listener is removed:
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
-Returns a reference to the EventEmitter, so that calls can be chained.
Methods
Optional[capture
get
set
- set
Max Listeners(n): this By default
-EventEmitters will print a warning if more than10listeners are -added for a particular event. This is a useful default that helps finding -memory leaks. Theemitter.setMaxListeners()method allows the limit to be -modified for this specificEventEmitterinstance. The value can be set toInfinity(or0) to indicate an unlimited number of listeners.Returns a reference to the
-EventEmitter, so that calls can be chained.Parameters
- n: number
Returns this
Interface HttpErrorClass<TCode>
Interface describing what an HttpError class should look like. -This helps us make sure all HttpError classes have the same utility static functions.
-new HttpErrorClassnew (message?: string, options?: HttpErrorOptions): HttpError<TCode>;
isInstance: ((error: unknown) => error is HttpError<TCode>);
statusCode: TCode;
uri: NamedNode<string>;
}
Type Parameters
Index
Constructors
Properties
Constructors
constructor
- new
Http Error Class(message?, options?): HttpError<TCode> Parameters
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns HttpError<TCode>
Interface HttpErrorOptions
cause?: unknown;
errorCode?: string;
metadata?: RepresentationMetadata;
}
Implemented by
Index
Properties
Interface HttpServerFactory
A factory for HTTP servers.
-createServer: (() => Promise<Server<typeof IncomingMessage, typeof ServerResponse>>);
}
Implemented by
Index
Properties
Interface IdentifierGenerator
Utility class for generating container identifiers.
-extractPod: ((identifier: ResourceIdentifier) => ResourceIdentifier);
generate: ((name: string) => ResourceIdentifier);
}
Implemented by
Index
Properties
Properties
extract
Extracts the root pod this identifier would be in. -This assumes the identifier of that pod was generated by the same instance of this interface.
-generate
Generates container identifiers based on an input name. -This is simply string generation, no resource-related checks are run.
-Interface IdentifierStrategy
Captures the behavior of container identifiers in a certain storage configuration.
-contains: ((container: ResourceIdentifier, identifier: ResourceIdentifier, transitive: boolean) => boolean);
getParentContainer: ((identifier: ResourceIdentifier) => ResourceIdentifier);
isRootContainer: ((identifier: ResourceIdentifier) => boolean);
supportsIdentifier: ((identifier: ResourceIdentifier) => boolean);
}
Implemented by
Index
Properties
Properties
contains
Checks if the given container would contain the given identifier. -This does not check that either of these identifiers actually exist. -This is similar to calling getParentContainer on an identifier -and comparing the result.
-If transitive is false this only checks if container is the direct parent container of identifier.
get
Generates the identifier of the container this resource would be a member of. -This does not check if that identifier actually exists. -Will throw an error if the input identifier is a root container or is not supported.
-is
Checks if the input corresponds to the identifier of a root container. -This does not check if this identifier actually exists.
-supports
Verifies if this identifier is supported. -This does not check if this identifier actually exists, -but checks if the identifier is in scope for this class.
-Interface IdentityProviderFactoryArgs
adapterFactory: AdapterFactory;
baseUrl: string;
clientCredentialsStore: ClientCredentialsStore;
errorHandler: ErrorHandler;
interactionRoute: InteractionRoute<never>;
jwkGenerator: JwkGenerator;
oidcPath: string;
promptFactory: PromptFactory;
responseWriter: ResponseWriter;
showStackTrace: boolean;
storage: KeyValueStorage<string, string[]>;
}
Index
Properties
adapter
Factory that creates the adapter used for OIDC data storage.
-base
Base URL of the server.
-client
Store containing the generated client credentials with their associated WebID.
-error
Used to convert errors thrown by the OIDC library.
-interaction
The route where requests should be redirected to in case of an OIDC interaction.
-jwk
Generates the JWK used for signing and decryption.
-oidc
Path for all requests targeting the OIDC library.
-prompt
Used to generate new prompt that are needed in addition to the defaults prompts.
-response
Used to write out errors thrown by the OIDC library.
-show
Extra information will be added to the error output if this is true.
-storage
Storage used to store cookie keys, so they can be re-used in case of multithreading.
-Interface IdentityProviderHttpHandlerArgs
cookieStore: CookieStore;
handler: InteractionHandler;
providerFactory: ProviderFactory;
}
Index
Properties
Interface IndexedStorage<T>
A storage solution that allows for more complex queries than a key/value storage -and allows setting indexes on specific keys.
-create: (<TType>(type: TType, value: CreateTypeObject<T[TType]>) => Promise<TypeObject<T[TType]>>);
createIndex: (<TType>(type: TType, key: StringKey<T[TType]>) => Promise<void>);
defineType: (<TType>(type: TType, description: T[TType]) => Promise<void>);
delete: (<TType>(type: TType, id: string) => Promise<void>);
entries: (<TType>(type: TType) => AsyncIterableIterator<TypeObject<T[TType]>>);
find: (<TType>(type: TType, query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<TypeObject<T[TType]>[]>);
findIds: (<TType>(type: TType, query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<string[]>);
get: (<TType>(type: TType, id: string) => Promise<undefined | TypeObject<T[TType]>>);
has: (<TType>(type: TType, id: string) => Promise<boolean>);
set: (<TType>(type: TType, value: TypeObject<T[TType]>) => Promise<void>);
setField: (<TType, TKey>(type: TType, id: string, key: TKey, value: ValueType<T[TType][TKey]>) => Promise<void>);
}
Type Parameters
- T extends IndexTypeCollection<T>
Implemented by
Properties
create
Creates an object of the given type. -The storage will generate an identifier for the newly created object.
-Type declaration
- <TType>(type, value): Promise<TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type to create.
- - value: CreateTypeObject<T[TType]>
The value to set for the created object.
-
Returns Promise<TypeObject<T[TType]>>
A representation of the newly created object, including its new identifier.
-- type: TType
create
Creates an index on a key of the given type, to allow for better queries involving those keys. -Similar to IndexedStorage.defineType these calls need to happen first.
-define
Informs the storage of the definition of a specific type. -A definition is a key/value object with the values being a valid ValueTypeDescription. -Generally, this call needs to happen for every type of this storage, -and before any calls are made to interact with the data.
-delete
Deletes the given object. -This will also delete all objects that reference that object if the corresponding key is not optional.
-entries
Returns an iterator over all objects of the given type.
-Type declaration
- <TType>(type): AsyncIterableIterator<TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type to iterate over.
-
Returns AsyncIterableIterator<TypeObject<T[TType]>>
- type: TType
find
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<TypeObject<T[TType]>[]>)
Finds all objects matching a specific IndexedQuery.
-Type declaration
- <TType>(type, query): Promise<TypeObject<T[TType]>[]>
Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<TypeObject<T[TType]>[]>
A list of objects matching the query.
-- type: TType
find
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<string[]>)
Similar to IndexedStorage.find, but only returns the identifiers of the found objects.
-Type declaration
- <TType>(type, query): Promise<string[]>
Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<string[]>
A list of identifiers of the matching objects.
-- type: TType
get
Returns the object of the given type with the given identifier.
-Type declaration
- <TType>(type, id): Promise<undefined | TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type of object to get.
- - id: string
The identifier of that object.
-
Returns Promise<undefined | TypeObject<T[TType]>>
A representation of the object, or
-undefinedif there is no object of that type with that identifier.- type: TType
has
Returns true if the object of the given type with the given identifier exists.
set
Sets the value of a specific object. -The identifier in the object is used to identify the object.
-Type declaration
- <TType>(type, value): Promise<void>
Type Parameters
Parameters
- type: TType
The type of the object to set.
- - value: TypeObject<T[TType]>
The new value for the object.
-
Returns Promise<void>
- type: TType
set
Sets the value of one specific field in an object.
-Interface Initializable
Allows for initializing state or executing logic when the application is started. -Use this interface to add initialization logic to classes that already extend some other type. -NOTE: classes without an existing extends-relation should extend from Initializer instead!
-Implemented by
Index
Properties
Interface InteractionHandlerInput
accountId?: string;
oidcInteraction?: Interaction;
operation: Operation;
}
Index
Properties
Properties
Optionalaccount
The account id of the agent doing the request if one could be found.
-Optionaloidc
Will be defined if the OIDC library expects us to resolve an interaction it can't handle itself, -such as logging a user in.
-operation
The operation to execute.
-Interface InteractionRoute<T>
Routes are used to handle the pathing for API calls.
-They can have dynamic values in the paths they support. -Typings are used to indicate the keys used to indicate what the corresponding values are.
-getPath: ((parameters?: Record<T, string>) => string);
matchPath: ((path: string) => undefined | Record<T, string>);
}
Type Parameters
Implemented by
Properties
get
Returns the path that is the result of having the specified values for the dynamic parameters.
-Will throw an error in case the input parameters object is missing one of the expected keys.
Type declaration
- (parameters?): string
Parameters
Optionalparameters: Record<T, string>Values for the dynamic parameters.
-
Returns string
match
Checks if the provided path matches the route (pattern).
-The result will be undefined if there is no match.
If there is a match the result object will have the corresponding values for all the parameters.
-Interface JsonInteractionHandlerInput
accountId?: string;
json: unknown;
metadata: RepresentationMetadata;
method: string;
oidcInteraction?: Interaction;
target: ResourceIdentifier;
}
Index
Properties
Properties
Optionalaccount
The account id of the agent doing the request if one could be found.
-json
The JSON body of the request.
-metadata
The metadata of the request.
-method
The operation to execute.
-Optionaloidc
Will be defined if the OIDC library expects us to resolve an interaction it can't handle itself, -such as logging a user in.
-target
The resource that is being targeted.
-Interface JsonRepresentation<T>
Contains a JSON object and any associated metadata. -Similar to a Representation but with all the data in memory instead of as a stream -and specific to JSON.
-Type Parameters
Interface JsonView
An interface that can be used by classes that can provide a view besides doing an action. -Designed to be used by a JsonInteractionHandler that has a view explaining what JSON input it supports.
-getView: ((input: JsonInteractionHandlerInput) => Promise<JsonRepresentation<Dict<Json>>>);
}
Implemented by
Index
Properties
Interface JwkGenerator
Generates an asymmetric JWK.
-The functions always need to return the same value.
-alg: AsymmetricSigningAlgorithm;
getPrivateKey: (() => Promise<AlgJwk>);
getPublicKey: (() => Promise<AlgJwk>);
}
Implemented by
Index
Properties
Interface KeyValueStorage<TKey, TValue>
A simple storage solution that can be used for internal values that need to be stored. -To prevent potential issues, keys should be urlencoded before calling the storage.
-delete: ((key: TKey) => Promise<boolean>);
entries: (() => AsyncIterableIterator<[TKey, TValue]>);
get: ((key: TKey) => Promise<undefined | TValue>);
has: ((key: TKey) => Promise<boolean>);
set: ((key: TKey, value: TValue) => Promise<KeyValueStorage<TKey, TValue>>);
}
Type Parameters
Hierarchy (view full)
- KeyValueStorage
Implemented by
Properties
delete
Deletes the value stored for the given key.
-Type declaration
- (key): Promise<boolean>
Parameters
- key: TKey
Key to delete.
-
Returns Promise<boolean>
If there was a value to delete.
-- key: TKey
entries
An iterable of entries in the storage.
-get
Returns the value stored for the given identifier.
-undefined if no value is stored.
has
Checks whether there is a value stored for the given key.
-set
Sets the value for the given key.
-Type declaration
- (key, value): Promise<KeyValueStorage<TKey, TValue>>
Returns Promise<KeyValueStorage<TKey, TValue>>
The storage.
-
Interface LinkWebIdHandlerArgs
baseUrl: string;
ownershipValidator: OwnershipValidator;
podStore: PodStore;
storageStrategy: StorageLocationStrategy;
webIdRoute: WebIdLinkRoute;
webIdStore: WebIdStore;
}
Index
Properties
Properties
base
Base URL of the server.
-Used to indicate in the response what the object of the solid:oidcIssuer triple should be.
ownership
Validates whether the user trying to link the WebID is the actual owner of that WebID.
-pod
Pod store to find out if the account created the pod containing the WebID.
-storage
Before calling the OwnershipValidator, we first check if the target WebID is in a pod owned by the user.
-web
Route used to generate the WebID link resource URL.
-web
WebID store to store WebID links.
-Interface Logger
Logs messages, with convenience methods to log on a specific level.
-debug: ((message: string) => Logger);
error: ((message: string) => Logger);
info: ((message: string) => Logger);
log: ((level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly", message: string, meta?: LogMetadata) => Logger);
silly: ((message: string) => Logger);
verbose: ((message: string) => Logger);
warn: ((message: string) => Logger);
}
Hierarchy (view full)
- SimpleLogger
- Logger
Implemented by
Properties
debug
Log a message at the 'debug' level.
-error
Log a message at the 'error' level.
-info
Log a message at the 'info' level.
-log
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly", message: string, meta?: LogMetadata) => Logger)
Log the given message at the given level. -If the internal level is higher than the given level, the message may be voided.
-Type declaration
- (level, message, meta?): Logger
Parameters
- level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly"The level to log at.
- - message: string
The message to log.
- Optionalmeta: LogMetadataOptional metadata to include in the log message.
-
Returns Logger
- level:
silly
Log a message at the 'silly' level.
-verbose
Log a message at the 'verbose' level.
-warn
Log a message at the 'warn' level.
-Interface LoggerFactory
Instantiates new logger instances.
-Implemented by
Index
Properties
Interface LoginStorage<T>
A IndexedStorage where the defineType function
-takes an extra parameter to indicate if the type corresponds to a login method.
-This is useful for storages that want to add extra requirements based on the data being edited.
In practice, we use this because we want to require accounts to have at least 1 login method.
-create: (<TType>(type: TType, value: CreateTypeObject<T[TType]>) => Promise<TypeObject<T[TType]>>);
createIndex: (<TType>(type: TType, key: StringKey<T[TType]>) => Promise<void>);
defineType: (<TType>(type: TType, description: T[TType], isLogin: boolean) => Promise<void>);
delete: (<TType>(type: TType, id: string) => Promise<void>);
entries: (<TType>(type: TType) => AsyncIterableIterator<TypeObject<T[TType]>>);
find: (<TType>(type: TType, query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<TypeObject<T[TType]>[]>);
findIds: (<TType>(type: TType, query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<string[]>);
get: (<TType>(type: TType, id: string) => Promise<undefined | TypeObject<T[TType]>>);
has: (<TType>(type: TType, id: string) => Promise<boolean>);
set: (<TType>(type: TType, value: TypeObject<T[TType]>) => Promise<void>);
setField: (<TType, TKey>(type: TType, id: string, key: TKey, value: ValueType<T[TType][TKey]>) => Promise<void>);
}
Type Parameters
- T extends IndexTypeCollection<T>
Hierarchy
- Omit<IndexedStorage<T>, "defineType">
- LoginStorage
Implemented by
Properties
create
Creates an object of the given type. -The storage will generate an identifier for the newly created object.
-Type declaration
- <TType>(type, value): Promise<TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type to create.
- - value: CreateTypeObject<T[TType]>
The value to set for the created object.
-
Returns Promise<TypeObject<T[TType]>>
A representation of the newly created object, including its new identifier.
-- type: TType
create
Creates an index on a key of the given type, to allow for better queries involving those keys. -Similar to IndexedStorage.defineType these calls need to happen first.
-define
Defines a type in the storage, just like in an IndexedStorage, -but additionally it needs to be indicated if the type corresponds to a login method or not.
-delete
Deletes the given object. -This will also delete all objects that reference that object if the corresponding key is not optional.
-entries
Returns an iterator over all objects of the given type.
-Type declaration
- <TType>(type): AsyncIterableIterator<TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type to iterate over.
-
Returns AsyncIterableIterator<TypeObject<T[TType]>>
- type: TType
find
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<TypeObject<T[TType]>[]>)
Finds all objects matching a specific IndexedQuery.
-Type declaration
- <TType>(type, query): Promise<TypeObject<T[TType]>[]>
Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<TypeObject<T[TType]>[]>
A list of objects matching the query.
-- type: TType
find
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}) => Promise<string[]>)
Similar to IndexedStorage.find, but only returns the identifiers of the found objects.
-Type declaration
- <TType>(type, query): Promise<string[]>
Type Parameters
Parameters
- type: TType
The type of objects to find.
- - query: {
[K in string | number | symbol]?: ValueType<T[TType][K]> | (T[TType][K] extends `id:${U}`
? {
[K in string | number | symbol]?: (ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<T[U][K]> | (T[U][K] extends `id:${infer U}` ? { [K in "id" | keyof T[U]]?: ValueType<...> | ... 1 more ... | undefined; } : never) | undefined; } : never) | undefined)
}
: never)
}The query to execute.
-
Returns Promise<string[]>
A list of identifiers of the matching objects.
-- type: TType
get
Returns the object of the given type with the given identifier.
-Type declaration
- <TType>(type, id): Promise<undefined | TypeObject<T[TType]>>
Type Parameters
Parameters
- type: TType
The type of object to get.
- - id: string
The identifier of that object.
-
Returns Promise<undefined | TypeObject<T[TType]>>
A representation of the object, or
-undefinedif there is no object of that type with that identifier.- type: TType
has
Returns true if the object of the given type with the given identifier exists.
set
Sets the value of a specific object. -The identifier in the object is used to identify the object.
-Type declaration
- <TType>(type, value): Promise<void>
Type Parameters
Parameters
- type: TType
The type of the object to set.
- - value: TypeObject<T[TType]>
The new value for the object.
-
Returns Promise<void>
- type: TType
set
Sets the value of one specific field in an object.
-Interface NotificationChannel
Internal representation of a notification channel. -Most of the fields are those defined in -https://solidproject.org/TR/2022/notifications-protocol-20221231#notification-channel-data-model
-We only support notification channels with a single topic.
-accept?: string;
endAt?: number;
id: string;
lastEmit?: number;
rate?: number;
receiveFrom?: string;
sendTo?: string;
sender?: string;
startAt?: number;
state?: string;
topic: string;
type: string;
}
Hierarchy (view full)
- NotificationChannel
Properties
Optionalaccept
The media type in which the receiver expects the notifications.
-Optionalend
When the channel should stop existing, in milliseconds since epoch.
-id
The unique identifier of the channel.
-Optionallast
Internal value that we use to track when this channel last sent a notification.
-Optionalrate
The minimal time required between notifications, in milliseconds.
-Optionalreceive
The resource receivers can use to establish a connection and receive notifications.
-Optionalsend
The resource on the receiver where notifications can be sent.
-Optionalsender
Can be used to identify the sender.
-Optionalstart
When the channel should start sending notifications, in milliseconds since epoch.
-Optionalstate
The state parameter sent by the receiver. -This is used to send a notification when the channel is established and the topic resource has a different state.
-topic
The resource this channel sends notifications about.
-type
The channel type.
-Interface NotificationChannelStorage
Stores all the information necessary to keep track of notification channels. -Besides the standard channel info it also stores features specific to a certain channel type.
-This storage assumes that a channel can only have a single identifier as its topic.
-add: ((channel: NotificationChannel) => Promise<void>);
delete: ((id: string) => Promise<boolean>);
get: ((id: string) => Promise<undefined | NotificationChannel>);
getAll: ((topic: ResourceIdentifier) => Promise<string[]>);
update: ((channel: NotificationChannel) => Promise<void>);
}
Implemented by
Properties
add
Adds the given channel to the storage.
-Type declaration
- (channel): Promise<void>
Parameters
- channel: NotificationChannel
Channel to add.
-
Returns Promise<void>
- channel: NotificationChannel
delete
Deletes the given notification channel from the storage. -Returns true if the channel existed.
-Type declaration
- (id): Promise<boolean>
Parameters
- id: string
The identifier of the notification channel
-
Returns Promise<boolean>
- id: string
get
Returns the requested channel.
-undefined if no match was found or if the notification channel expired.
Type declaration
- (id): Promise<undefined | NotificationChannel>
Parameters
- id: string
The identifier of the notification channel.
-
Returns Promise<undefined | NotificationChannel>
- id: string
get
Returns the identifiers of all notification channel entries that have the given identifier as their topic. -The identifiers can potentially correspond to expired channels.
-Type declaration
- (topic): Promise<string[]>
Parameters
- topic: ResourceIdentifier
The identifier that is the topic.
-
Returns Promise<string[]>
- topic: ResourceIdentifier
update
Updates the given notification channel.
-The id and the topic can not be updated.
Type declaration
- (channel): Promise<void>
Parameters
- channel: NotificationChannel
The channel to update.
-
Returns Promise<void>
- channel: NotificationChannel
Interface NotificationChannelType
A specific channel type as defined at -https://solidproject.org/TR/2022/notifications-protocol-20221231#notification-channel-types.
-All functions that take a NotificationChannel as input
-only need to support channels generated by an initChannel on the same class.
completeChannel: ((channel: NotificationChannel) => Promise<void>);
extractModes: ((channel: NotificationChannel) => Promise<AccessMap>);
getDescription: (() => SubscriptionService);
initChannel: ((data: Store<Quad, Quad, Quad, Quad>, credentials: Credentials) => Promise<NotificationChannel>);
toJsonLd: ((channel: NotificationChannel) => Promise<Record<string, unknown>>);
}
Implemented by
Index
Properties
Properties
complete
This function will be called after the serialized channel is sent back as a response, -allowing for any final actions that need to happen.
-Type declaration
- (channel): Promise<void>
Parameters
- channel: NotificationChannel
The notification channel that is completed.
-
Returns Promise<void>
- channel: NotificationChannel
extract
Determines which modes are required to allow the given notification channel.
-Type declaration
- (channel): Promise<AccessMap>
Parameters
- channel: NotificationChannel
The notification channel to verify.
-
Returns Promise<AccessMap>
The required modes.
-- channel: NotificationChannel
get
Returns the SubscriptionService that describes how to subscribe to this channel type.
-init
Validate and convert the input quads into a NotificationChannel.
-Type declaration
- (data, credentials): Promise<NotificationChannel>
Parameters
- data: Store<Quad, Quad, Quad, Quad>
The input quads.
- - credentials: Credentials
The credentials of the agent doing the request.
-
Returns Promise<NotificationChannel>
- data: Store<Quad, Quad, Quad, Quad>
to
Converts a NotificationChannel to a serialized JSON-LD representation.
-Type declaration
- (channel): Promise<Record<string, unknown>>
Parameters
- channel: NotificationChannel
The notification channel to serialize.
-
Returns Promise<Record<string, unknown>>
- channel: NotificationChannel
Interface NotificationEmitterInput
channel: NotificationChannel;
representation: Representation;
}
Index
Properties
Interface NotificationHandlerInput
activity?:
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">;
channel: NotificationChannel;
metadata?: RepresentationMetadata;
topic: ResourceIdentifier;
}
Properties
Optionalactivity
| NamedNode<"https://www.w3.org/ns/activitystreams#Create">
| NamedNode<"https://www.w3.org/ns/activitystreams#object">
| NamedNode<"https://www.w3.org/ns/activitystreams#target">
| NamedNode<"https://www.w3.org/ns/activitystreams#Add">
| NamedNode<"https://www.w3.org/ns/activitystreams#Delete">
| NamedNode<"https://www.w3.org/ns/activitystreams#Remove">
| NamedNode<"https://www.w3.org/ns/activitystreams#Update">
channel
Optionalmetadata
topic
Interface NotificationSubscriberArgs
authorizer: Authorizer;
channelType: NotificationChannelType;
converter: RepresentationConverter;
credentialsExtractor: CredentialsExtractor;
maxDuration?: number;
permissionReader: PermissionReader;
storage: NotificationChannelStorage;
}
Index
Properties
Properties
authorizer
Used to determine if the request has the necessary permissions.
-channel
The NotificationChannelType with all the necessary information.
-converter
RepresentationConverter used to convert input data into RDF.
-credentials
Used to extract the credentials from the request.
-Optionalmax
Overrides the expiration feature of channels, by making sure they always expire after the maxDuration value.
-If the expiration of the channel is shorter than maxDuration, the original value will be kept.
-Value is set in minutes. 0 is infinite.
-Defaults to 20160 minutes, which is 2 weeks.
permission
Used to determine which permissions the found credentials have.
-storage
Storage used to store the channels.
-Interface OAuthErrorFields
These are the fields that can occur in an OAuth error response as described in RFC 6749, §4.1.2.1. -https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1
-This interface is identical to the ErrorOut interface of the oidc-provider library,
-but having our own version reduces the part of the codebase that is dependent on that library.
error: string;
error_description?: string;
scope?: string;
state?: string;
}
Index
Properties
Interface Operation
A single REST operation.
-body: Representation;
conditions?: Conditions;
method: string;
preferences: RepresentationPreferences;
target: ResourceIdentifier;
}
Index
Properties
Properties
body
Representation of the body and metadata headers.
-Optionalconditions
Conditions the resource must fulfill for a valid operation.
-method
The HTTP method (GET/POST/PUT/PATCH/DELETE/etc.).
-preferences
Representation preferences of the response. Will be empty if there are none.
-target
Identifier of the target.
-Interface OperationHttpHandlerInput
operation: Operation;
request: HttpRequest;
response: HttpResponse;
}
Hierarchy (view full)
- HttpHandlerInput
- OperationHttpHandlerInput
Interface OriginalUrlExtractorArgs
identifierStrategy: IdentifierStrategy;
includeQueryString?: boolean;
}
Index
Properties
Interface ParsingHttpHandlerArgs
errorHandler: ErrorHandler;
operationHandler: OperationHttpHandler;
requestParser: RequestParser;
responseWriter: ResponseWriter;
}
Index
Properties
Interface PasswordLoginHandlerArgs
accountStore: AccountStore;
cookieStore: CookieStore;
passwordStore: PasswordStore;
}
Index
Properties
Interface PasswordStore
Responsible for storing everything related to email/password based login combinations.
-authenticate: ((email: string, password: string) => Promise<{
accountId: string;
id: string;
}>);
confirmVerification: ((id: string) => Promise<void>);
create: ((email: string, accountId: string, password: string) => Promise<string>);
delete: ((id: string) => Promise<void>);
findByAccount: ((accountId: string) => Promise<{
email: string;
id: string;
}[]>);
findByEmail: ((email: string) => Promise<undefined | {
accountId: string;
id: string;
}>);
get: ((id: string) => Promise<undefined | {
accountId: string;
email: string;
}>);
update: ((id: string, password: string) => Promise<void>);
}
Implemented by
Index
Properties
Properties
authenticate
accountId: string;
id: string;
}>)
Authenticate if the email and password are correct and return the account and login ID if they are. -Throw an error if they are not.
-Type declaration
- (email, password): Promise<{
accountId: string;
id: string;
}> Parameters
- email: string
The user's email.
- - password: string
This user's password.
-
Returns Promise<{
accountId: string;
id: string;
}>- email: string
- (email, password): Promise<{
confirm
Confirms that the login has been verified.
-This can be used with, for example, email verification.
-The login can only be used after it is verified.
-In case verification is not required, this should be called immediately after the create call.
Type declaration
- (id): Promise<void>
Parameters
- id: string
ID of the login.
-
Returns Promise<void>
- id: string
create
Creates a new login entry for this account.
-Type declaration
- (email, accountId, password): Promise<string>
Parameters
- email: string
Email to log in with.
- - accountId: string
Account ID.
- - password: string
Password to authenticate with.
-
Returns Promise<string>
- email: string
delete
Delete the login entry.
-Type declaration
- (id): Promise<void>
Parameters
- id: string
ID of the login object.
-
Returns Promise<void>
- id: string
find
email: string;
id: string;
}[]>)
Find all login objects created by this account.
-Type declaration
- (accountId): Promise<{
email: string;
id: string;
}[]> Parameters
- accountId: string
ID of the account to find the logins for.
-
Returns Promise<{
email: string;
id: string;
}[]>- accountId: string
- (accountId): Promise<{
find
accountId: string;
id: string;
}>)
Finds the account and login ID associated with this email.
-Type declaration
- (email): Promise<undefined | {
accountId: string;
id: string;
}> Parameters
- email: string
Email to find the information for.
-
Returns Promise<undefined | {
accountId: string;
id: string;
}>- email: string
- (email): Promise<undefined | {
get
accountId: string;
email: string;
}>)
Finds the account and email associated with this login ID.
-Type declaration
- (id): Promise<undefined | {
accountId: string;
email: string;
}> Parameters
- id: string
The ID of the login object.
-
Returns Promise<undefined | {
accountId: string;
email: string;
}>- id: string
- (id): Promise<undefined | {
update
Changes the password.
-Type declaration
- (id, password): Promise<void>
Parameters
- id: string
ID of the login object.
- - password: string
The new password.
-
Returns Promise<void>
- id: string
Interface Patch
Represents the changes needed for a PATCH request.
-binary: boolean;
data: Guarded<Readable>;
isEmpty: boolean;
metadata: RepresentationMetadata;
}
Hierarchy (view full)
Properties
binary
Whether the data stream consists of binary/string chunks -(as opposed to complex objects).
-data
The raw data stream for this representation.
-is
Whether the data stream is empty. -This being true does not imply that the data stream has a length of more than 0, -only that it is a possibility and should be read to be sure.
-metadata
The corresponding metadata.
-Interface PermissionReaderInput
Index
Properties
Interface PodCreatorInput
accountId: string;
name?: string;
settings?: Record<string, unknown>;
webId?: string;
}
Properties
account
The ID of the account to create the pod for.
-Optionalname
The name to use when generating the base URL of the pod. -If undefined, the pod will be created in the root of the server.
-Optionalsettings
Additional settings to use when generating a pod.
-Optionalweb
The WebID to use for creation of the pod. -This WebID will be used in the templates to, for example, determine who has access. -If none is provided, the WebID generated by the creator will be used, -in which case that WebID will also be linked to the account.
-Interface PodCreatorOutput
Index
Properties
Interface PodGenerator
Generates an empty resource store to be used as a new pod. -It is also responsible for storing any relevant variables needed to instantiate this resource store. -These can then be used when the server is restarted to re-instantiate those stores.
-Implemented by
Index
Properties
Properties
generate
Creates a ResourceStore based on the given input. -Should error if there already is a store for the given identifier.
-Type declaration
- (settings): Promise<ResourceStore>
Parameters
- settings: PodSettings
Parameters to be used for the new pod.
-
Returns Promise<ResourceStore>
A new ResourceStore to be used for the new pod.
-- settings: PodSettings
Interface PodManager
Covers all functions related to pod management. -In the future this should also include delete, and potentially recovery functions.
-Implemented by
Index
Properties
Properties
create
Creates a pod for the given settings.
-Type declaration
- (settings, overwrite): Promise<void>
Parameters
- settings: PodSettings
Settings describing the pod.
- - overwrite: boolean
If the creation should proceed if there already is a resource there.
-
Returns Promise<void>
- settings: PodSettings
Interface PodSettings
Metadata related to pod generation.
-base: ResourceIdentifier;
email?: string;
name?: string;
oidcIssuer?: string;
template?: string;
webId: string;
}
Hierarchy
- Dict<unknown>
- PodSettings
Properties
base
The root of the pod. Determines where the pod will be created.
-Optionalemail
E-mail of the owner. Used in provisioning templates.
-Optionalname
Name of the owner. Used in provisioning templates.
-Optionaloidc
The OIDC issuer of the owner's WebId. Necessary if the WebID in the pod is registered with the IDP.
-Optionaltemplate
Required for dynamic pod configuration. -Indicates the name of the config to use for the pod.
-web
The WebId of the owner of this pod.
-Interface PodStore
Can be used to create new pods and find relevant information.
-Also keeps track of the owners of a pod.
-The visible parameter indicates if an owner should be publicly exposed or not.
create: ((accountId: string, settings: PodSettings, overwrite: boolean) => Promise<string>);
findByBaseUrl: ((baseUrl: string) => Promise<undefined | {
accountId: string;
id: string;
}>);
findPods: ((accountId: string) => Promise<{
baseUrl: string;
id: string;
}[]>);
get: ((id: string) => Promise<undefined | {
accountId: string;
baseUrl: string;
}>);
getOwners: ((id: string) => Promise<undefined | {
visible: boolean;
webId: string;
}[]>);
removeOwner: ((id: string, webId: string) => Promise<void>);
updateOwner: ((id: string, webId: string, visible: boolean) => Promise<void>);
}
Implemented by
Index
Properties
Properties
create
Creates a new pod and updates the account accordingly.
-Type declaration
- (accountId, settings, overwrite): Promise<string>
Parameters
- accountId: string
Identifier of the account that is creating the account.
- - settings: PodSettings
Settings to create a pod with.
- - overwrite: boolean
If the pod is allowed to overwrite existing data.
-
Returns Promise<string>
The ID of the new pod resource.
-- accountId: string
find
accountId: string;
id: string;
}>)
Find the ID of the account that created the given pod.
-Type declaration
- (baseUrl): Promise<undefined | {
accountId: string;
id: string;
}> Parameters
- baseUrl: string
The pod base URL.
-
Returns Promise<undefined | {
accountId: string;
id: string;
}>- baseUrl: string
- (baseUrl): Promise<undefined | {
find
baseUrl: string;
id: string;
}[]>)
Find all the pod resources created by the given account ID.
-Type declaration
- (accountId): Promise<{
baseUrl: string;
id: string;
}[]> Parameters
- accountId: string
Account ID to find pod resources for.
-
Returns Promise<{
baseUrl: string;
id: string;
}[]>- accountId: string
- (accountId): Promise<{
get
accountId: string;
baseUrl: string;
}>)
Returns the baseURl and account that created the pod for the given pod ID.
-Type declaration
- (id): Promise<undefined | {
accountId: string;
baseUrl: string;
}> Parameters
- id: string
ID of the pod.
-
Returns Promise<undefined | {
accountId: string;
baseUrl: string;
}>- id: string
- (id): Promise<undefined | {
get
visible: boolean;
webId: string;
}[]>)
Find all owners for the given pod ID.
-Type declaration
- (id): Promise<undefined | {
visible: boolean;
webId: string;
}[]> Parameters
- id: string
ID of the pod.
-
Returns Promise<undefined | {
visible: boolean;
webId: string;
}[]>- id: string
- (id): Promise<undefined | {
remove
Remove an owner from a pod. -This should not remove the last owner as a pod always needs to have at least one owner. -https://solidproject.org/TR/2022/protocol-20221231#server-storage-track-owner
-Type declaration
- (id, webId): Promise<void>
Parameters
- id: string
ID of the pod.
- - webId: string
WebID of the owner.
-
Returns Promise<void>
- id: string
update
Add or update an owner of a pod. -In case there already is an owner with this WebID, it will be updated, -otherwise a new owner will be added.
-Type declaration
- (id, webId, visible): Promise<void>
Parameters
- id: string
ID of the pod.
- - webId: string
WebID of the owner.
- - visible: boolean
Whether the owner wants to be exposed or not.
-
Returns Promise<void>
- id: string
Interface ProviderFactory
Returns a Provider of OIDC interactions.
-Implemented by
Index
Properties
Interface RdfStorePatcherInput
identifier: ResourceIdentifier;
patch: Patch;
store: Store<Quad, Quad, Quad, Quad>;
}
Index
Properties
Properties
identifier
Identifier of the resource that will be patched
-patch
The changes represented by a Patch object
-store
The store on which the patch will be executed. -Note the RdfStorePatcher is allowed to make changes to the store. -This means the store object might be modified by the patch.
-Interface ReadWriteLocker
Allows the locking of resources which is needed for non-atomic ResourceStores.
-withReadLock: (<T>(identifier: ResourceIdentifier, whileLocked: (() => PromiseOrValue<T>)) => Promise<T>);
withWriteLock: (<T>(identifier: ResourceIdentifier, whileLocked: (() => PromiseOrValue<T>)) => Promise<T>);
}
Hierarchy (view full)
- ReadWriteLocker
Implemented by
Index
Properties
Properties
with
Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that only require reading the resource.
-Type declaration
- <T>(identifier, whileLocked): Promise<T>
Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
with
Run the given function while the resource is locked. -The lock will be released when the (async) input function resolves. -This function should be used for operations that could modify the resource.
-Type declaration
- <T>(identifier, whileLocked): Promise<T>
Type Parameters
Parameters
- identifier: ResourceIdentifier
Identifier of the resource that needs to be locked.
- - whileLocked: (() => PromiseOrValue<T>)
A function to execute while the resource is locked.
-- (): PromiseOrValue<T>
Returns PromiseOrValue<T>
Returns Promise<T>
A promise resolving when the lock is released.
-- identifier: ResourceIdentifier
Interface RedirectHttpErrorClass<TCode>
Interface describing what a RedirectHttpError class should look like.
-Makes sure a location value is always needed.
new RedirectHttpErrorClassnew (location: string, message?: string, options?: HttpErrorOptions): RedirectHttpError<TCode>;
isInstance: ((error: unknown) => error is HttpError<TCode>);
statusCode: TCode;
uri: NamedNode<string>;
}
Type Parameters
Hierarchy
- Omit<HttpErrorClass<TCode>, "new">
- RedirectHttpErrorClass
Index
Constructors
Properties
Constructors
constructor
- new
Redirect Http Error Class(location, message?, options?): RedirectHttpError<TCode> Parameters
- location: string
Optionalmessage: stringOptionaloptions: HttpErrorOptions
Returns RedirectHttpError<TCode>
Interface RedisSettings
db?: number;
namespacePrefix?: string;
password?: string;
username?: string;
}
Index
Properties
Interface Representation
A representation of a resource.
-binary: boolean;
data: Guarded<Readable>;
isEmpty: boolean;
metadata: RepresentationMetadata;
}
Hierarchy (view full)
- Representation
Implemented by
Properties
binary
Whether the data stream consists of binary/string chunks -(as opposed to complex objects).
-data
The raw data stream for this representation.
-is
Whether the data stream is empty. -This being true does not imply that the data stream has a length of more than 0, -only that it is a possibility and should be read to be sure.
-metadata
The corresponding metadata.
-Interface RepresentationConverterArgs
identifier: ResourceIdentifier;
preferences: RepresentationPreferences;
representation: Representation;
}
Index
Properties
Interface RepresentationPatcherInput<T>
identifier: ResourceIdentifier;
patch: Patch;
representation?: T;
}
Type Parameters
Index
Properties
Interface RepresentationPreferences
Contains preferences along multiple content negotiation dimensions.
-All dimensions are optional for ease of constructing; either undefined
-or an empty ValuePreferences can indicate that no preferences were specified.
charset?: ValuePreferences;
datetime?: ValuePreferences;
encoding?: ValuePreferences;
language?: ValuePreferences;
range?: {
parts: {
end?: number;
start: number;
}[];
unit: string;
};
type?: ValuePreferences;
}
Interface ResourceLink
contentType?: string;
filePath: string;
identifier: ResourceIdentifier;
isMetadata: boolean;
}
Index
Properties
Interface ResourceLocker
An interface for classes that only have 1 way to lock interfaces. -In general this should only be used by components implementing the ReadWriteLocker interface. -Other components that require locking of resources should use that interface.
-acquire: ((identifier: ResourceIdentifier) => Promise<void>);
release: ((identifier: ResourceIdentifier) => Promise<void>);
}
Implemented by
Properties
acquire
Acquires a lock on the requested identifier. -The promise will resolve when the lock has been acquired.
-Type declaration
- (identifier): Promise<void>
Parameters
- identifier: ResourceIdentifier
Resource to acquire a lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
release
Releases a lock on the requested identifier. -The promise will resolve when the lock has been released. -If there is no lock on the resource, an error should be thrown.
-Type declaration
- (identifier): Promise<void>
Parameters
- identifier: ResourceIdentifier
Resource to release the lock on.
-
Returns Promise<void>
- identifier: ResourceIdentifier
Interface ResourceSet
A set containing resources.
-Hierarchy (view full)
- ResourceSet
Implemented by
Index
Properties
Properties
has
Checks whether a resource exists in this ResourceSet.
-Type declaration
- (identifier): Promise<boolean>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
Interface ResourceStore
A ResourceStore represents a collection of resources. -It has been designed such that each of its methods -can be implemented in an atomic way: for each CRUD operation, only one -dedicated method needs to be called. A fifth method enables the optimization -of partial updates with PATCH. It is up to the implementer of the interface to -(not) make an implementation atomic.
-ResourceStores are also responsible for taking auxiliary resources into account -should those be relevant to the store.
-addResource: ((container: ResourceIdentifier, representation: Representation, conditions?: Conditions) => Promise<ChangeMap>);
deleteResource: ((identifier: ResourceIdentifier, conditions?: Conditions) => Promise<ChangeMap>);
getRepresentation: ((identifier: ResourceIdentifier, preferences: RepresentationPreferences, conditions?: Conditions) => Promise<Representation>);
hasResource: ((identifier: ResourceIdentifier) => Promise<boolean>);
modifyResource: ((identifier: ResourceIdentifier, patch: Patch, conditions?: Conditions) => Promise<ChangeMap>);
setRepresentation: ((identifier: ResourceIdentifier, representation: Representation, conditions?: Conditions) => Promise<ChangeMap>);
}
Hierarchy (view full)
- ResourceSet
- ResourceStore
Implemented by
Index
Properties
Properties
add
Creates a new resource in the container.
-Type declaration
- (container, representation, conditions?): Promise<ChangeMap>
Parameters
- container: ResourceIdentifier
Container in which to create a resource.
- - representation: Representation
Representation of the new resource
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- container: ResourceIdentifier
delete
Deletes a resource.
-Type declaration
- (identifier, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to delete.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
get
Retrieves a representation of a resource.
-Type declaration
- (identifier, preferences, conditions?): Promise<Representation>
Parameters
- identifier: ResourceIdentifier
Identifier of the resource to read.
- - preferences: RepresentationPreferences
Preferences indicating desired representations.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<Representation>
A representation corresponding to the identifier.
-- identifier: ResourceIdentifier
has
Checks whether a resource exists in this ResourceSet.
-Type declaration
- (identifier): Promise<boolean>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to check.
-
Returns Promise<boolean>
A promise resolving if the resource already exists.
-- identifier: ResourceIdentifier
modify
Sets or updates the representation of a resource, -creating a new resource and intermediary containers as needed.
-Type declaration
- (identifier, patch, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - patch: Patch
Description of which parts to update.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
set
Sets or replaces the representation of a resource, -creating a new resource and intermediary containers as needed.
-Type declaration
- (identifier, representation, conditions?): Promise<ChangeMap>
Parameters
- identifier: ResourceIdentifier
Identifier of resource to update.
- - representation: Representation
New representation of the resource.
- Optionalconditions: ConditionsOptional conditions under which to proceed.
-
Returns Promise<ChangeMap>
A ChangeMap.
-- identifier: ResourceIdentifier
Interface ResourcesGenerator
Generator used to create resources relative to a given base identifier. -Note that this is not an AsyncHandler since it returns an AsyncIterable instead of a promise.
-generate: ((location: ResourceIdentifier, options: Dict<unknown>) => AsyncIterable<Resource>);
}
Implemented by
Index
Properties
Properties
generate
Generates resources with the given options. -The output Iterable should be sorted so that containers always appear before their contents.
-Type declaration
- (location, options): AsyncIterable<Resource>
Parameters
- location: ResourceIdentifier
Base identifier.
- - options: Dict<unknown>
Options that can be used when generating resources.
-
Returns AsyncIterable<Resource>
A map where the keys are the identifiers and the values the corresponding representations to store.
-- location: ResourceIdentifier
Interface RouterHandlerArgs
allowedMethods?: string[];
allowedPathNames?: string[];
baseUrl?: string;
handler: HttpHandler;
targetExtractor: TargetExtractor;
}
Hierarchy (view full)
- BaseRouterHandlerArgs<HttpHandler>
- RouterHandlerArgs
Index
Properties
Properties
Optionalallowed
The allowed method(s). * can be used to indicate all methods are allowed.
-Default is [ '*' ].
Optionalallowed
Regular expression(s) used to match the target URL.
-The base URl without trailing slash will be stripped of before applying the regular expressions,
-so the input will always start with a /.
-Default is [ '.*' ].
Optionalbase
The base URL of the server.
-Not required if no value is provided for allowedPathNames.
handler
The handler to call if all checks pass.
-target
Interface SeededAccountInitializerArgs
accountStore: AccountStore;
configFilePath?: string;
passwordStore: PasswordStore;
podCreator: PodCreator;
}
Index
Properties
Interface SetMultiMap<TKey, TVal>
A SetMultiMap is a Map where a single key can have multiple unique values.
-Deleting a key removes all bindings with this key from the Map.
-Setting a value for a key replaces all previous bindings with this key.
-Using an empty Set when calling the set function is the same as deleting that key.
[iterator]: (() => IterableIterator<[TKey, TVal]>);
[toStringTag]: string;
add: ((key: TKey, value: TVal | ReadonlySet<TVal>) => this);
asMap: (() => ReadonlyMap<TKey, ReadonlySet<TVal>>);
deleteEntry: ((key: TKey, value: TVal) => boolean);
distinctKeys: (() => IterableIterator<TKey>);
entries: (() => IterableIterator<[TKey, TVal]>);
entrySets: (() => IterableIterator<[TKey, ReadonlySet<TVal>]>);
forEach: ((callbackfn: ((value: TVal, key: TKey, map: SetMultiMap<TKey, TVal>) => void), thisArg?: unknown) => void);
get: ((key: TKey) => undefined | ReadonlySet<TVal>);
hasEntry: ((key: TKey, value: TVal) => boolean);
size: number;
valueSets: (() => IterableIterator<ReadonlySet<TVal>>);
values: (() => IterableIterator<TVal>);
clear(): void;
delete(key: TKey): boolean;
has(key: TKey): boolean;
keys(): IterableIterator<TKey>;
set(key: TKey, value: TVal | ReadonlySet<TVal>): this;
}
Type Parameters
Hierarchy
Implemented by
Index
Properties
Methods
Properties
[iterator]
Iterates over all key/value bindings in this Map.
-Readonly[to
add
Adds the given key/value binding to the Map.
-as
Returns a Readonly Map representation of this Map.
-delete
Deletes the given key/value binding from the Map.
-distinct
Iterates over all distinct keys in this Map.
-entries
Iterates over all key/value bindings in this Map.
-entry
Iterates over all distinct keys in this Map, together with a Set of their values.
-for
Loops over all key/value bindings.
-get
Returns all values stored for the given key.
-Returns undefined if there are no values for this key.
has
Returns true if this key/value binding exists in the Map.
-Readonlysize
value
Iterates over all distinct keys and returns their Set of values.
-values
Iterates over all values in this Map.
- Methods
clear
delete
- delete(key): boolean
Parameters
- key: TKey
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.
-
has
- has(key): boolean
Parameters
- key: TKey
Returns boolean
boolean indicating whether an element with the specified key exists or not.
-
keys
set
Interface SimpleLogger
Logs messages on a specific level.
-log: ((level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly", message: string, meta?: LogMetadata) => SimpleLogger);
}
Hierarchy (view full)
- SimpleLogger
Index
Properties
Properties
log
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly", message: string, meta?: LogMetadata) => SimpleLogger)
Log the given message at the given level. -If the internal level is higher than the given level, the message may be voided.
-Type declaration
- (level, message, meta?): SimpleLogger
Parameters
- level:
| "error"
| "warn"
| "info"
| "verbose"
| "debug"
| "silly"The level to log at.
- - message: string
The message to log.
- Optionalmeta: LogMetadataOptional metadata to include in the log message.
-
Returns SimpleLogger
- level:
Interface SingleThreaded
Indicates a class is only meant to work in singlethreaded setups and is thus not threadsafe.
-Implemented by
Interface SizeReporter<T>
A SizeReporter's only purpose (at the moment) is to calculate the size -of a resource. How the size is calculated or what unit it is in is defined by -the class implementing this interface. -One might use the amount of bytes and another might use the amount of triples -stored in a resource.
-calculateChunkSize: ((chunk: T) => Promise<number>);
estimateSize: ((metadata: RepresentationMetadata) => Promise<undefined | number>);
getSize: ((identifier: ResourceIdentifier) => Promise<Size>);
getUnit: (() => string);
}
Type Parameters
Implemented by
Index
Properties
Properties
calculate
Calculate the size of a chunk based on which SizeReporter is being used
-Type declaration
- (chunk): Promise<number>
Parameters
- chunk: T
the chunk of which you want the size
-
Returns Promise<number>
the size of the passed chunk as a number
-- chunk: T
estimate
Estimate the size of a body / request by looking at its metadata
-Type declaration
- (metadata): Promise<undefined | number>
Parameters
- metadata: RepresentationMetadata
the metadata of the resource you want an estimated size of
-
Returns Promise<undefined | number>
the estimated size of the body / request or undefined if no -meaningful estimation can be made
-- metadata: RepresentationMetadata
get
Get the size of a given resource
-Type declaration
- (identifier): Promise<Size>
Parameters
- identifier: ResourceIdentifier
the resource of which you want the size
-
Returns Promise<Size>
The size of the resource as a Size object calculated recursively -if the identifier leads to a container
-- identifier: ResourceIdentifier
get
Get the unit as a string in which a SizeReporter returns data
-Interface SliceStreamOptions
allowHalfOpen?: boolean;
autoDestroy?: boolean;
decodeStrings?: boolean;
defaultEncoding?: BufferEncoding;
emitClose?: boolean;
encoding?: BufferEncoding;
end?: number;
highWaterMark?: number;
objectMode?: boolean;
readableHighWaterMark?: number;
readableObjectMode?: boolean;
signal?: AbortSignal;
size?: number;
start: number;
writableCorked?: number;
writableHighWaterMark?: number;
writableObjectMode?: boolean;
construct?(this: Transform, callback: ((error?: null | Error) => void)): void;
destroy?(this: Transform, error: null | Error, callback: ((error: null | Error) => void)): void;
final?(this: Transform, callback: ((error?: null | Error) => void)): void;
flush?(this: Transform, callback: TransformCallback): void;
read?(this: Transform, size: number): void;
transform?(this: Transform, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
write?(this: Transform, chunk: any, encoding: BufferEncoding, callback: ((error?: null | Error) => void)): void;
writev?(this: Transform, chunks: {
chunk: any;
encoding: BufferEncoding;
}[], callback: ((error?: null | Error) => void)): void;
}
Hierarchy
- TransformOptions
- SliceStreamOptions
Index
Properties
Methods
Properties
Optionalallow
Optionalauto
Optionaldecode
Optionaldefault
Optionalemit
Optionalencoding
Optionalend
Optionalhigh
Optionalobject
Optionalreadable
Optionalreadable
Optionalsignal
When provided the corresponding AbortController can be used to cancel an asynchronous action.
Optionalsize
start
Optionalwritable
Optionalwritable
Optionalwritable
Interface SparqlUpdatePatch
A specific type of Patch corresponding to a SPARQL update.
-algebra: Update;
binary: boolean;
data: Guarded<Readable>;
isEmpty: boolean;
metadata: RepresentationMetadata;
}
Hierarchy (view full)
- Patch
- SparqlUpdatePatch
Properties
algebra
Algebra corresponding to the SPARQL update.
-binary
Whether the data stream consists of binary/string chunks -(as opposed to complex objects).
-data
The raw data stream for this representation.
-is
Whether the data stream is empty. -This being true does not imply that the data stream has a length of more than 0, -only that it is a possibility and should be read to be sure.
-metadata
The corresponding metadata.
-Interface StorageLocationStrategy
Interface used to find the storage a specific identifier is located in.
-getStorageIdentifier: ((identifier: ResourceIdentifier) => Promise<ResourceIdentifier>);
}
Implemented by
Index
Properties
Interface StreamingHttpEmitterInput
channel: NotificationChannel;
representation: Representation;
}
Index
Properties
Interface SubfolderResourcesGeneratorArgs
Input arguments required for BaseResourcesGenerator
-factory: FileIdentifierMapperFactory<FileIdentifierMapper>;
metadataStrategy: AuxiliaryStrategy;
store: ResourceSet;
templateEngine: TemplateEngine<Dict<unknown>>;
templateExtension?: string;
}
Index
Properties
Properties
factory
Factory used to generate mapper relative to the base identifier.
-metadata
The metadataStrategy
-store
The default ResourceStore
-template
Template engine for generating the resources.
-Optionaltemplate
The extension of files that need to be interpreted as templates. -Will be removed to generate the identifier.
-Interface SubscriptionService
A subscription service description as based on the specification data model -https://solidproject.org/TR/2022/notifications-protocol-20221231#subscription-service-data-model
-@context: ["https://www.w3.org/ns/solid/notification/v1"];
channelType: string;
feature: string[];
id: string;
}
Index
Properties
Interface SystemError
Interface for Node.js System errors
-Node.js generates system errors when exceptions occur within its runtime environment. -These usually occur when an application violates an operating system constraint. -For example, a system error will occur if an application attempts to read a file that does not exist.
-address?: string;
code: string;
dest?: string;
errno: string | number;
info?: unknown;
message: string;
name: string;
path?: string;
port?: string;
stack?: string;
syscall: string;
}
Hierarchy
- Error
- SystemError
Properties
Optionaladdress
If present, the address to which a network connection failed.
-code
The string error code. -Full list: https://man7.org/linux/man-pages/man3/errno.3.html
-Optionaldest
If present, the file path destination when reporting a file system error.
-errno
The system-provided error number.
-Optionalinfo
If present, extra details about the error condition.
-message
name
Optionalpath
If present, the file path when reporting a file system error.
-Optionalport
If present, the network connection port that is not available.
-Optionalstack
syscall
The name of the system call that triggered the error.
-Interface TemplateOptions
codeTemplatesPath?: string;
contentType?: string;
extension?: string;
mainTemplatePath?: string;
}
Index
Properties
Interface TemplatePath
Index
Properties
Interface TemplateString
Index
Properties
Interface TemplatedResourcesGenerator
Generator used to create resources relative to a given base identifier. -Similar to ResourcesGenerator, but takes as input a string -indicating where the templates are stored that need to be used for resource generation.
-generate: ((templateFolder: string, location: ResourceIdentifier, options: Dict<unknown>) => AsyncIterable<Resource>);
}
Implemented by
Index
Properties
Properties
generate
Generates resources with the given options, based on the given template folder. -The output Iterable should be sorted so that containers always appear before their contents.
-Type declaration
- (templateFolder, location, options): AsyncIterable<Resource>
Parameters
- templateFolder: string
Folder where the templates are located.
- - location: ResourceIdentifier
Base identifier.
- - options: Dict<unknown>
Options that can be used when generating resources.
-
Returns AsyncIterable<Resource>
A map where the keys are the identifiers and the values the corresponding representations to store.
-- templateFolder: string
Interface V6MigrationInitializerArgs
accountStorage: KeyValueStorage<string, Account | Settings>;
cleanupStorages: KeyValueStorage<string, any>[];
clientCredentialsStorage: KeyValueStorage<string, ClientCredentials>;
newAccountStorage: AccountLoginStorage<Record<string, never>>;
newSetupStorage: KeyValueStorage<string, string>;
setupStorage: KeyValueStorage<string, string>;
skipConfirmation?: boolean;
versionKey: string;
}
Index
Properties
account
The storage in which account data of the previous version is stored.
-cleanup
Storages for which all entries need to be removed.
-client
The storage in which client credentials are stored from the previous version.
-new
The storage that will contain the account data in the new format. -Wrong typings to prevent Components.js typing issues.
-new
The storage that will contain the setup entries in the new format.
-setup
The storage in which all setup values are stored, including the version of the server.
-Optionalskip
If true, no confirmation prompt will be printed to the stdout.
-version
The key necessary to get the version from the setupStorage.
Interface WacAllowHttpHandlerArgs
credentialsExtractor: CredentialsExtractor;
modesExtractor: ModesExtractor;
operationHandler: OperationHttpHandler;
permissionReader: PermissionReader;
}
Index
Properties
Interface WebIdStore
Stores and updates WebID to Account links.
-create: ((webId: string, accountId: string) => Promise<string>);
delete: ((linkId: string) => Promise<void>);
findLinks: ((accountId: string) => Promise<{
id: string;
webId: string;
}[]>);
get: ((linkId: string) => Promise<undefined | {
accountId: string;
webId: string;
}>);
isLinked: ((webId: string, accountId: string) => Promise<boolean>);
}
Implemented by
Properties
create
Creates a new WebID link for the given WebID and account.
-Type declaration
- (webId, accountId): Promise<string>
Parameters
- webId: string
WebID to link.
- - accountId: string
Returns Promise<string>
ID of the link.
-- webId: string
delete
Deletes the link with the given ID
-Type declaration
- (linkId): Promise<void>
Parameters
- linkId: string
ID of the link.
-
Returns Promise<void>
- linkId: string
find
id: string;
webId: string;
}[]>)
Finds all links associated with the given account.
-Type declaration
- (accountId): Promise<{
id: string;
webId: string;
}[]> Parameters
- accountId: string
ID of the account.
-
Returns Promise<{
id: string;
webId: string;
}[]>- accountId: string
- (accountId): Promise<{
get
accountId: string;
webId: string;
}>)
Finds the account and WebID of the link with the given ID.
-is
Determines if a WebID is linked to an account.
-Type declaration
- (webId, accountId): Promise<boolean>
Parameters
- webId: string
WebID to check.
- - accountId: string
ID of the account.
-
Returns Promise<boolean>
- webId: string
Interface WebSocketChannel2023
A NotificationChannel containing the necessary fields for a WebSocketChannel2023 channel.
-accept?: string;
endAt?: number;
id: string;
lastEmit?: number;
rate?: number;
receiveFrom: string;
sendTo?: string;
sender?: string;
startAt?: number;
state?: string;
topic: string;
type: "http://www.w3.org/ns/solid/notifications#WebSocketChannel2023";
}
Hierarchy (view full)
- NotificationChannel
- WebSocketChannel2023
Properties
Optionalaccept
The media type in which the receiver expects the notifications.
-Optionalend
When the channel should stop existing, in milliseconds since epoch.
-id
The unique identifier of the channel.
-Optionallast
Internal value that we use to track when this channel last sent a notification.
-Optionalrate
The minimal time required between notifications, in milliseconds.
-receive
The WebSocket through which the channel will send notifications.
-Optionalsend
The resource on the receiver where notifications can be sent.
-Optionalsender
Can be used to identify the sender.
-Optionalstart
When the channel should start sending notifications, in milliseconds since epoch.
-Optionalstate
The state parameter sent by the receiver. -This is used to send a notification when the channel is established and the topic resource has a different state.
-topic
The resource this channel sends notifications about.
-type
The "notify:WebSocketChannel2023" type.
-Interface WebhookChannel2023
A NotificationChannel containing the necessary fields for a WebhookChannel2023 channel.
-accept?: string;
endAt?: number;
id: string;
lastEmit?: number;
rate?: number;
receiveFrom?: string;
sendTo: string;
sender?: string;
startAt?: number;
state?: string;
topic: string;
type: "http://www.w3.org/ns/solid/notifications#WebhookChannel2023";
}
Hierarchy (view full)
- NotificationChannel
- WebhookChannel2023
Properties
Optionalaccept
The media type in which the receiver expects the notifications.
-Optionalend
When the channel should stop existing, in milliseconds since epoch.
-id
The unique identifier of the channel.
-Optionallast
Internal value that we use to track when this channel last sent a notification.
-Optionalrate
The minimal time required between notifications, in milliseconds.
-Optionalreceive
The resource receivers can use to establish a connection and receive notifications.
-send
Where the notifications have to be sent.
-Optionalsender
Can be used to identify the sender.
-Optionalstart
When the channel should start sending notifications, in milliseconds since epoch.
-Optionalstate
The state parameter sent by the receiver. -This is used to send a notification when the channel is established and the topic resource has a different state.
-topic
The resource this channel sends notifications about.
-type
The "WebhookChannel2023" type.
-Community Solid Server - v7.1.0
Index
Enumerations
Classes
Interfaces
Type Aliases
Variables
Functions
Type Alias AccountIdKey
Type Alias AccountIdRoute
A route that includes an account identifier.
-Type Alias AccountInteractionResults
account?: string;
} & InteractionResults
InteractionResults extended with our custom key for tracking a user's account ID.
-Type Alias AccountLoginStorage<T>
A LoginStorage with specific typings to ensure other types can reference account IDs -without actually needing to specify it explicitly in their storage type.
-Type Parameters
- T extends Record<string, Record<string, ValueTypeDescription<keyof T | typeof ACCOUNT_TYPE>>>
Type Alias AccountSettings
rememberLogin?: boolean;
}
Type Alias AclPermissionSet
Type Alias ActivityEmitter
An event emitter used to report changes made to resources.
-Both generic change events and ActivityStream-specific events are emitted.
Type Alias AsyncHandlerInput<T>
Type Parameters
- T extends AsyncHandler<unknown, unknown>
Type Alias AsyncHandlerOutput<T>
Type Parameters
- T extends AsyncHandler<unknown, unknown>
Type Alias ChangeMap
An IdentifierMap containing one entry for each resource that was created, updated or deleted -by this operation. Where the value is a RepresentationMetadata -containing extra information about the change of the resource.
-Type Alias ClientCredentialsIdRoute
An AccountIdRoute that also includes a credentials identifier.
-Type Alias CreateTypeObject<T>
Input expected for create() call in IndexedStorage.
-This is the same as TypeObject but without the index key.
Type Parameters
- T extends Record<string, ValueTypeDescription>
Type Alias Credentials
agent?: {
webId: string;
};
client?: {
clientId: string;
};
issuer?: {
url: string;
};
[key: string]: unknown;
}
Credentials identifying an entity accessing or owning data.
-Type Alias CredentialsIdKey
Type Alias EmptyMapConstructor
A simplified version of MapConstructor that only allows creating an empty Map.
-Type Alias EmptyObject
Type Alias ExtendedRoute<TRoute, TParam>
A route that adds a parameter to an existing route type.
-Type Parameters
- TRoute extends InteractionRoute<string>
- TParam extends string
Type Alias Guarded<T>
A stream that is guarded from emitting errors when there are no listeners. -If an error occurs while no listener is attached, -it will store the error and emit it once a listener is added (or a timeout occurs).
-Type Parameters
Type Alias HttpResponse
An outgoing HTTP response;
-Type Alias IndexRelation<TTypes>
child: {
key: string;
type: StringKey<TTypes>;
};
parent: {
key: VirtualKey<string>;
type: StringKey<TTypes>;
};
}
A parent/child relation description in a WrappedIndexedStorage.
-Type Parameters
Type Alias IndexTypeCollection<T>
The full description of all the types of an IndexedStorage.
-Type Parameters
Type Alias IndexTypeDescription<TType>
The description of a single type in an IndexedStorage.
-Type Parameters
Type Alias IndexedQuery<T, TType, TDepth>
? never
: {
[K in keyof T[TType] | typeof INDEX_ID_KEY]?: ValueType<T[TType][K]> | (T[TType][K] extends `${typeof INDEX_ID_KEY}:${infer U}`
? IndexedQuery<T, U, Prev[TDepth]>
: never)
}
Object that represents a valid query starting from a specific type on an IndexedStorage. -The keys of the object need to be one or more keys from the starting type, -with the values being corresponding valid values of an object of that type. -If the value definition of a key is one that contains the identifier of a different type, -the value in the query can also be a nested object that has the same IndexedQuery requirements for that type. -This can be done recursively.
-E.g., if the storage has the following definition:
- {
account: {},
pod: { baseUrl: 'string', account: 'id:account' },
pod: { owner: 'string', pod: 'id:pod' },
}
-A valid query on the pod type could be { pod: '123456' },
-but also { pod: { baseUrl: 'http://example.com/pod/', account: { id: '789' }}}.
Type Parameters
- T extends IndexTypeCollection<T>
- TType extends keyof T
- TDepth extends number = 10
Type Alias Interaction
Type Alias LogLevel
Different log levels, from most important to least important.
-Type Alias LoginOutputType
accountId: string;
remember?: boolean;
}
Output type that is expected of handlers logging an account in.
-Type declaration
account
Id: string The ID of the account that logged in.
-Optionalremember?: booleanIf this account should be remembered or not. -Setting this to
-undefinedwill keep the setting as it currently is.
Type Alias MetadataGraph
| NamedNode
| BlankNode
| DefaultGraph
| string
Type Alias MetadataIdentifier
Type Alias MetadataRecord
Type Alias MetadataValue
| NamedNode
| BlankNode
| Literal
| string
| (
| NamedNode
| Literal
| BlankNode
| string)[]
Type Alias ModifyOptions<T>
Options describing the necessary changes when calling modify.
-Type Parameters
- T extends SetMultiMap<unknown, unknown>
Type Alias OptionalKey<T>
Used to filter on optional keys in a IndexedStorage definition.
-Type Parameters
Type Alias PartialVocabulary<TBase>
namespace: TBase;
} & Partial<Record<string, string>> & {
terms: {
namespace: NamedNode<TBase>;
} & Partial<Record<string, NamedNode>>;
}
A Vocabulary where all the non-namespace fields are of unknown value. -This is a fallback in case createVocabulary gets called with a non-strict string array.
-Type Parameters
Type Alias PasswordIdKey
Type Alias PasswordIdRoute
An AccountIdRoute that also includes a password login identifier.
-Type Alias PatchHandlerInput<T>
Type Parameters
- T extends ResourceStore = ResourceStore
Type Alias PermissionSet
A data interface indicating which permissions are required (based on the context).
-Type Alias PodIdKey
Type Alias PodIdRoute
An AccountIdRoute that also includes a pod identifier.
-Type Alias RouteParameter<TRoute>
The parameters supported for the given route.
-Type Parameters
- TRoute extends InteractionRoute<string>
Type Alias Template
Type Alias TemplateFileName
Type Alias TypeObject<TDesc>
-readonly [K in Exclude<keyof TDesc, OptionalKey<TDesc>>]: ValueType<TDesc[K]>
} & {
-readonly [K in keyof TDesc]?: ValueType<TDesc[K]>
} & {
id: string;
}
Converts a IndexedStorage definition of a specific type -to the typing an object would have that is returned as an output on function calls.
-Type Parameters
- TDesc extends Record<string, ValueTypeDescription>
Type Alias ValidatorInput
Type Alias ValuePreference
value: string;
weight: number;
}
A single entry of a ValuePreferences object. -Useful when doing operations on such an object.
-Type Alias ValuePreferences
[key: string]: number;
}
Represents preferred values along a single content negotiation dimension.
-The number represents how preferred this value is from 0 to 1. -Follows the quality values rule from RFC 7231: -"The weight is normalized to a real number in the range 0 through 1, -where 0.001 is the least preferred and 1 is the most preferred; a -value of 0 means "not acceptable"."
-Because of an open issue in Components.js we cannot use Record<string, number> right now.
-https://github.com/LinkedSoftwareDependencies/Components-Generator.js/issues/103
Type Alias ValueType<T>
? boolean
: T extends "number" | "number?"
? number
: string) | (T extends `${string}?`
? undefined
: never)
Converts a ValueTypeDescription to the type it should be interpreted as.
-Type Parameters
- T extends ValueTypeDescription
Type Alias ValueTypeDescription<TType>
| "string"
| "boolean"
| "number"
| (TType extends string
? `${typeof INDEX_ID_KEY}:${TType}`
: never)}${"?" | ""}`
Used to define the value of a key in a type entry of a IndexedStorage.
-Valid values are "string", "boolean", "number" and "id:TYPE",
-with TYPE being one of the types in the definition.
-In the latter case this means that key points to an identifier of the specified type.
-A ? can be appended to the type to indicate this key is optional.
Type Parameters
Type Alias VirtualKey<TChild>
Key used to link to child objects in a WrappedIndexedStorage.
-Type Parameters
Type Alias VirtualObject
id: string;
[key: VirtualKey<string>]: Record<string, VirtualObject>;
[key: string]: unknown;
}
Object stored in the wrapped KeyValueStorage in a WrappedIndexedStorage.
-Type Alias Vocabulary<TBase, TKey>
terms: TermVocabulary<ValueVocabulary<TBase, TKey>>;
}
Contains a namespace and keys linking to the entries in this namespace.
-The terms field contains the same values but as NamedNode instead of string.
Type Parameters
Type Alias WebIdLinkKey
Type Alias WebIdLinkRoute
An AccountIdRoute that also includes a Web ID link identifier.
-Type Alias YargsOptions
Variable ACCOUNT_ID_KEYConst
Variable ACCOUNT_PROMPTConst
The prompt that is used to track the account ID of a user during an OIDC interaction.
-The already existing login prompt in the InteractionResults
-is used to track the WebID that is chosen in an OIDC interaction.
Variable ACCOUNT_SETTINGS_REMEMBER_LOGINConst
Settings parameter used to determine if the user wants the login to be remembered.
-Variable ACCOUNT_STORAGE_DESCRIPTIONConst
rememberLogin: "boolean?";
} = ...
Variable ACCOUNT_TYPEConst
Variable ACLConst
| "default"
| "accessTo"
| "agent"
| "agentClass"
| "agentGroup"
| "AuthenticatedAgent"
| "Authorization"
| "mode"
| "Write"
| "Read"
| "Append"
| "Control"> = ...
Variable ACPConst
| "agent"
| "AccessControlResource"
| "grant"
| "attribute"
| "resource"
| "accessControl"
| "memberAccessControl"
| "apply"
| "allow"
| "deny"
| "allOf"
| "anyOf"
| "noneOf"
| "client"
| "issuer"
| "vc"> = ...
Variable APPLICATION_JSONConst
Variable APPLICATION_LD_JSONConst
Variable APPLICATION_OCTET_STREAMConst
Variable APPLICATION_SPARQL_UPDATEConst
Variable APPLICATION_X_WWW_FORM_URLENCODEDConst
Variable ASConst
| "object"
| "target"
| "Add"
| "Create"
| "Delete"
| "Remove"
| "Update"> = ...
Variable AUTHConst
Variable BaseActivityEmitterConst
A class implementation of ActivityEmitter.
-Variable CLIENT_CREDENTIALS_STORAGE_DESCRIPTIONConst
accountId: "id:account";
label: "string";
secret: "string";
webId: "string";
} = ...
Variable CLIENT_CREDENTIALS_STORAGE_TYPEConst
Variable CONTENT_LENGTHConst
Variable CONTENT_LENGTH_TERMConst
Variable CONTENT_TYPEConst
Variable CONTENT_TYPE_TERMConst
Variable DCConst
Variable DEFAULT_CUSTOM_TYPESConst
acl: string;
acr: string;
meta: string;
} = ...
Variable DEFAULT_NOTIFICATION_FEATURESConst
The default notification features that are available on all channel types.
-Variable DEFAULT_SUBSCRIPTION_SHACLConst
@context: readonly ["https://w3c.github.io/shacl/shacl-jsonld-context/shacl.context.ld.json"];
@type: "sh:NodeShape";
closed: true;
property: readonly [{
maxCount: 1;
minCount: 1;
nodeKind: "sh:IRI";
path: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
}, {
maxCount: 1;
minCount: 1;
nodeKind: "sh:IRI";
path: "http://www.w3.org/ns/solid/notifications#topic";
}, unknown];
targetSubjectsOf: "http://www.w3.org/ns/solid/notifications#topic";
} = ...
The SHACL shape for the minimum requirements on a notification channel subscription request.
-Variable FOAFConst
Variable HHConst
Variable HTTPConst
Variable IANAConst
Variable INDEX_ID_KEYConst
The key that needs to be present in all output results of IndexedStorage.
-Variable INTERNAL_ALLConst
Variable INTERNAL_ERRORConst
Variable INTERNAL_QUADSConst
Variable JSON_LDConst
Variable LDPConst
| "contains"
| "BasicContainer"
| "Container"
| "Resource"> = ...
Variable LOG_LEVELSConst
Variable MAConst
Variable NOTIFYConst
| "accept"
| "channelType"
| "endAt"
| "feature"
| "rate"
| "receiveFrom"
| "startAt"
| "state"
| "sender"
| "sendTo"
| "subscription"
| "topic"
| "webhookAuth"
| "WebhookChannel2023"
| "WebSocketChannel2023"
| "StreamingHTTPChannel2023"> = ...
Variable OIDCConst
Variable OWNER_STORAGE_DESCRIPTIONConst
podId: "id:pod";
visible: "boolean";
webId: "string";
} = ...
Variable OWNER_STORAGE_TYPEConst
Variable PASSWORD_METHODConst
The constant used to identify email/password based login combinations in the map of logins an account has.
-Variable PASSWORD_STORAGE_DESCRIPTIONConst
accountId: "id:account";
email: "string";
password: "string";
verified: "boolean";
} = ...
Variable PASSWORD_STORAGE_TYPEConst
Variable PIMConst
Variable POD_STORAGE_DESCRIPTIONConst
accountId: "id:account";
baseUrl: "string";
} = ...
Variable POD_STORAGE_TYPEConst
Variable POSIXConst
Variable PREFERRED_PREFIXConst
Variable PREFERRED_PREFIX_TERMConst
Variable RDFConst
Variable RDFSConst
Variable SOLIDConst
| "deletes"
| "inserts"
| "oidcIssuer"
| "oidcIssuerRegistrationToken"
| "oidcRegistration"
| "storageDescription"
| "where"
| "InsertDeletePatch"> = ...
Variable SOLID_ASConst
Variable SOLID_ERRORConst
| "target"
| "disallowedMethod"
| "errorCode"
| "errorResponse"
| "stack"> = ...
Variable SOLID_ERROR_TERMConst
Variable SOLID_HTTPConst
| "accountCookie"
| "accountCookieExpiration"
| "end"
| "location"
| "start"
| "slug"
| "unit"> = ...
Variable SOLID_METAConst
| "value"
| "ResponseMetadata"
| "template"
| "contentTypeParameter"
| "preserve"
| "requestedAccess"
| "accessTarget"
| "accessMode"> = ...
Variable TEMPLATEConst
Variable TEMPLATE_VARIABLEConst
| "baseUrl"
| "rootFilePath"
| "sparqlEndpoint"
| "templateConfig"> = ...
Variable TEXT_HTMLConst
Variable TEXT_MARKDOWNConst
Variable TEXT_N3Const
Variable TEXT_TURTLEConst
Variable UNIT_BYTESConst
Variable URL_SCHEMAConst
Variable VANNConst
Variable VCARDConst
Variable WEBID_STORAGE_DESCRIPTIONConst
accountId: "id:account";
webId: "string";
} = ...
Variable WEBID_STORAGE_TYPEConst
Variable XSDConst
| "string"
| "dateTime"
| "duration"
| "integer"> = ...
Variable modulePathPlaceholderConst
A placeholder for the path to the @solid/community-server module root.
-The resolveAssetPath function will replace this string with the actual path.
controls.html.account.account wh
-
+
@@ -2505,7 +2505,7 @@ The most important one is probably controls.html.account.account wh
-
+
@@ -2516,7 +2516,7 @@ The most important one is probably controls.html.account.account wh
-
+
@@ -2527,7 +2527,7 @@ The most important one is probably controls.html.account.account wh
-
+
.community-solid-server.config.js:
-
+
@@ -1935,7 +1935,7 @@ such as the following .community-solid-server.config.js:
-
+
@@ -1946,7 +1946,7 @@ such as the following .community-solid-server.config.js:
-
+
@@ -1957,7 +1957,7 @@ such as the following .community-solid-server.config.js:
-
+
A route that stores a single absolute path.
-