From 0e7971b928f5b00d2dee4791fc9a18b7aeb47d96 Mon Sep 17 00:00:00 2001 From: Patrick Stewart Date: Thu, 14 Nov 2024 00:37:51 -0700 Subject: [PATCH] add: adding contracts package extracted contracts from existing code --- packages/contracts/lib/contracts.dart | 71 ++++ packages/contracts/lib/src/bus/bus.dart | 2 + .../contracts/lib/src/bus/bus_contract.dart | 196 ++++++++++++ .../lib/src/container/container.dart | 3 + .../lib/src/container/container_contract.dart | 134 ++++++++ .../contextual_binding_contract.dart | 42 +++ .../src/events/event_dispatcher_contract.dart | 199 ++++++++++++ packages/contracts/lib/src/events/events.dart | 2 + packages/contracts/lib/src/http/http.dart | 2 + .../contracts/lib/src/http/http_contract.dart | 299 +++++++++++++++++ packages/contracts/lib/src/model/model.dart | 2 + .../lib/src/model/model_contract.dart | 148 +++++++++ .../contracts/lib/src/pipeline/pipeline.dart | 2 + .../lib/src/pipeline/pipeline_contract.dart | 127 ++++++++ .../contracts/lib/src/process/process.dart | 2 + .../lib/src/process/process_contract.dart | 251 +++++++++++++++ packages/contracts/lib/src/queue/queue.dart | 2 + .../lib/src/queue/queue_contract.dart | 284 ++++++++++++++++ .../lib/src/reflection/reflection.dart | 2 + .../src/reflection/reflector_contract.dart | 148 +++++++++ .../contracts/lib/src/routing/routing.dart | 2 + .../lib/src/routing/routing_contract.dart | 260 +++++++++++++++ .../contracts/lib/src/support/support.dart | 2 + .../lib/src/support/support_contract.dart | 263 +++++++++++++++ .../contracts/lib/src/testing/testing.dart | 2 + .../lib/src/testing/testing_contract.dart | 302 ++++++++++++++++++ packages/contracts/pubspec.yaml | 13 + 27 files changed, 2762 insertions(+) create mode 100644 packages/contracts/lib/contracts.dart create mode 100644 packages/contracts/lib/src/bus/bus.dart create mode 100644 packages/contracts/lib/src/bus/bus_contract.dart create mode 100644 packages/contracts/lib/src/container/container.dart create mode 100644 packages/contracts/lib/src/container/container_contract.dart create mode 100644 packages/contracts/lib/src/container/contextual_binding_contract.dart create mode 100644 packages/contracts/lib/src/events/event_dispatcher_contract.dart create mode 100644 packages/contracts/lib/src/events/events.dart create mode 100644 packages/contracts/lib/src/http/http.dart create mode 100644 packages/contracts/lib/src/http/http_contract.dart create mode 100644 packages/contracts/lib/src/model/model.dart create mode 100644 packages/contracts/lib/src/model/model_contract.dart create mode 100644 packages/contracts/lib/src/pipeline/pipeline.dart create mode 100644 packages/contracts/lib/src/pipeline/pipeline_contract.dart create mode 100644 packages/contracts/lib/src/process/process.dart create mode 100644 packages/contracts/lib/src/process/process_contract.dart create mode 100644 packages/contracts/lib/src/queue/queue.dart create mode 100644 packages/contracts/lib/src/queue/queue_contract.dart create mode 100644 packages/contracts/lib/src/reflection/reflection.dart create mode 100644 packages/contracts/lib/src/reflection/reflector_contract.dart create mode 100644 packages/contracts/lib/src/routing/routing.dart create mode 100644 packages/contracts/lib/src/routing/routing_contract.dart create mode 100644 packages/contracts/lib/src/support/support.dart create mode 100644 packages/contracts/lib/src/support/support_contract.dart create mode 100644 packages/contracts/lib/src/testing/testing.dart create mode 100644 packages/contracts/lib/src/testing/testing_contract.dart create mode 100644 packages/contracts/pubspec.yaml diff --git a/packages/contracts/lib/contracts.dart b/packages/contracts/lib/contracts.dart new file mode 100644 index 0000000..473fb3f --- /dev/null +++ b/packages/contracts/lib/contracts.dart @@ -0,0 +1,71 @@ +/// Platform Contracts Library +/// +/// This library provides the core contracts (interfaces) that define +/// the Platform framework's API. These contracts ensure consistency +/// and interoperability between components while enabling loose coupling +/// and dependency injection. + +// Level 0: Core Foundation Contracts + +// Container contracts (from packages/container) +export 'src/container/container.dart'; + +// Reflection contracts (from packages/container) +export 'src/reflection/reflection.dart'; + +// Pipeline contracts (from packages/pipeline) +export 'src/pipeline/pipeline.dart'; + +// Level 1: Infrastructure Contracts + +// Events contracts (from packages/events) +export 'src/events/events.dart'; + +// Bus contracts (from packages/bus) +export 'src/bus/bus.dart'; + +// Model contracts (from packages/model) +export 'src/model/model.dart'; + +// Process contracts (from packages/process) +export 'src/process/process.dart'; + +// Support contracts (from packages/support) +export 'src/support/support.dart'; + +// Level 2: Core Services Contracts + +// Queue contracts (from packages/queue) +export 'src/queue/queue.dart'; + +// Level 3: HTTP Layer Contracts + +// Routing contracts (from packages/route) +export 'src/routing/routing.dart'; + +// HTTP contracts (from packages/core) +export 'src/http/http.dart'; + +// Testing Contracts + +// Testing contracts (from packages/testing) +export 'src/testing/testing.dart'; + +// All contracts have been extracted from implemented packages: +// - Container & Reflection (Level 0) +// - Pipeline (Level 0) +// - Events (Level 1) +// - Bus (Level 1) +// - Model (Level 1) +// - Process (Level 1) +// - Support (Level 1) +// - Queue (Level 2) +// - Route (Level 3) +// - HTTP (Level 3) +// - Testing + +// Next steps: +// 1. Update package dependencies to use these contracts +// 2. Implement contracts in each package +// 3. Add contract compliance tests +// 4. Document contract usage and patterns diff --git a/packages/contracts/lib/src/bus/bus.dart b/packages/contracts/lib/src/bus/bus.dart new file mode 100644 index 0000000..cd46d82 --- /dev/null +++ b/packages/contracts/lib/src/bus/bus.dart @@ -0,0 +1,2 @@ +/// Bus package contracts +export 'bus_contract.dart'; diff --git a/packages/contracts/lib/src/bus/bus_contract.dart b/packages/contracts/lib/src/bus/bus_contract.dart new file mode 100644 index 0000000..075ceee --- /dev/null +++ b/packages/contracts/lib/src/bus/bus_contract.dart @@ -0,0 +1,196 @@ +import 'package:meta/meta.dart'; + +/// Contract for commands. +/// +/// Laravel-compatible: Base interface for command objects that can be +/// dispatched through the command bus. +@sealed +abstract class CommandContract {} + +/// Contract for queueable commands. +/// +/// Laravel-compatible: Marks commands that should be processed +/// through the queue system. +@sealed +abstract class ShouldQueueCommand implements CommandContract {} + +/// Contract for command handlers. +/// +/// Laravel-compatible: Defines how command handlers should process +/// their associated commands, with platform-specific typing. +@sealed +abstract class HandlerContract { + /// Handles a command. + /// + /// Laravel-compatible: Core handler method with platform-specific + /// return type for more flexibility. + /// + /// Parameters: + /// - [command]: The command to handle. + Future handle(CommandContract command); +} + +/// Type definition for command pipe functions. +/// +/// Platform-specific: Defines transformation functions that can modify +/// commands as they flow through the pipeline. +typedef CommandPipe = CommandContract Function(CommandContract); + +/// Contract for command dispatching. +/// +/// This contract defines the core interface for dispatching +/// and processing commands through the command bus. +@sealed +abstract class CommandDispatcherContract { + /// Dispatches a command. + /// + /// Laravel-compatible: Core dispatch method. + /// + /// Parameters: + /// - [command]: The command to dispatch. + Future dispatch(CommandContract command); + + /// Dispatches a command synchronously. + /// + /// Platform-specific: Provides explicit sync dispatch with optional handler. + /// + /// Parameters: + /// - [command]: The command to dispatch. + /// - [handler]: Optional specific handler. + Future dispatchSync(CommandContract command, + [HandlerContract? handler]); + + /// Dispatches a command immediately. + /// + /// Laravel-compatible: Immediate dispatch without queueing. + /// Extended with optional handler parameter. + /// + /// Parameters: + /// - [command]: The command to dispatch. + /// - [handler]: Optional specific handler. + Future dispatchNow(CommandContract command, + [HandlerContract? handler]); + + /// Dispatches a command to queue. + /// + /// Laravel-compatible: Queue-based dispatch. + /// + /// Parameters: + /// - [command]: The command to queue. + Future dispatchToQueue(CommandContract command); + + /// Finds a command batch. + /// + /// Platform-specific: Provides batch lookup functionality. + /// + /// Parameters: + /// - [batchId]: The batch ID to find. + Future findBatch(String batchId); + + /// Creates a command batch. + /// + /// Laravel-compatible: Creates command batches. + /// Extended with platform-specific batch contract. + /// + /// Parameters: + /// - [commands]: Commands to include in batch. + PendingCommandBatchContract batch(List commands); + + /// Creates a command chain. + /// + /// Laravel-compatible: Creates command chains. + /// Extended with platform-specific chain contract. + /// + /// Parameters: + /// - [commands]: Commands to chain. + CommandChainContract chain(List commands); + + /// Maps command types to handlers. + /// + /// Platform-specific: Provides explicit handler mapping. + /// + /// Parameters: + /// - [handlers]: Map of command types to handler types. + CommandDispatcherContract map(Map handlers); + + /// Applies transformation pipes to commands. + /// + /// Platform-specific: Adds pipeline transformation support. + /// + /// Parameters: + /// - [pipes]: List of command transformation functions. + CommandDispatcherContract pipeThrough(List pipes); + + /// Dispatches after current response. + /// + /// Laravel-compatible: Delayed dispatch after response. + /// + /// Parameters: + /// - [command]: Command to dispatch later. + void dispatchAfterResponse(CommandContract command); +} + +/// Contract for command batches. +/// +/// Laravel-compatible: Defines batch structure and operations. +/// Extended with additional status tracking. +@sealed +abstract class CommandBatchContract { + /// Gets the batch ID. + String get id; + + /// Gets commands in the batch. + List get commands; + + /// Gets batch status. + /// + /// Platform-specific: Provides detailed status tracking. + String get status; + + /// Whether batch allows failures. + /// + /// Laravel-compatible: Controls batch failure handling. + bool get allowsFailures; + + /// Gets finished command count. + /// + /// Platform-specific: Tracks completion progress. + int get finished; + + /// Gets failed command count. + /// + /// Platform-specific: Tracks failure count. + int get failed; + + /// Gets pending command count. + /// + /// Platform-specific: Tracks remaining commands. + int get pending; +} + +/// Contract for pending command batches. +/// +/// Laravel-compatible: Defines batch configuration and dispatch. +@sealed +abstract class PendingCommandBatchContract { + /// Allows failures in batch. + /// + /// Laravel-compatible: Configures failure handling. + PendingCommandBatchContract allowFailures(); + + /// Dispatches the batch. + /// + /// Laravel-compatible: Executes the batch. + Future dispatch(); +} + +/// Contract for command chains. +/// +/// Laravel-compatible: Defines sequential command execution. +@sealed +abstract class CommandChainContract { + /// Dispatches the chain. + /// + /// Laravel-compatible: Executes commands in sequence. + Future dispatch(); +} diff --git a/packages/contracts/lib/src/container/container.dart b/packages/contracts/lib/src/container/container.dart new file mode 100644 index 0000000..88578ff --- /dev/null +++ b/packages/contracts/lib/src/container/container.dart @@ -0,0 +1,3 @@ +/// Container package contracts +export 'container_contract.dart'; +export 'contextual_binding_contract.dart'; diff --git a/packages/contracts/lib/src/container/container_contract.dart b/packages/contracts/lib/src/container/container_contract.dart new file mode 100644 index 0000000..dc2c414 --- /dev/null +++ b/packages/contracts/lib/src/container/container_contract.dart @@ -0,0 +1,134 @@ +import 'package:meta/meta.dart'; +import '../reflection/reflector_contract.dart'; + +/// Core container contract defining dependency injection functionality. +/// +/// This contract defines the interface that all dependency injection containers +/// must implement. It provides methods for registering and resolving dependencies, +/// creating child containers, and managing named instances. +@sealed +abstract class ContainerContract { + /// Gets the reflector instance used by this container. + ReflectorContract get reflector; + + /// Whether this is a root container (has no parent). + bool get isRoot; + + /// Creates a child container that inherits from this container. + /// + /// The child container can access all dependencies registered in its parent containers, + /// but can also define its own dependencies that override or extend the parent's. + /// This enables scoped dependency injection contexts. + ContainerContract createChild(); + + /// Checks if a type is registered in this container or its parents. + /// + /// Parameters: + /// - [T]: The type to check for. If [T] is dynamic, [t] must be provided. + /// - [t]: Optional type parameter that overrides [T] if provided. + /// + /// Returns true if the type is registered, false otherwise. + bool has([Type? t]); + + /// Checks if a named instance exists in this container or its parents. + /// + /// Parameters: + /// - [name]: The name to check for. + /// + /// Returns true if a named instance exists, false otherwise. + bool hasNamed(String name); + + /// Makes an instance of type [T]. + /// + /// This will: + /// 1. Return a singleton if registered + /// 2. Create an instance via factory if registered + /// 3. Use reflection to create a new instance + /// + /// Parameters: + /// - [type]: Optional type parameter that overrides [T] if provided. + /// + /// Throws: + /// - ReflectionException if [T] is not a class or has no default constructor + T make([Type? type]); + + /// Makes an instance of type [T] asynchronously. + /// + /// This will attempt to resolve a Future in the following order: + /// 1. Wrap a synchronous [T] in Future + /// 2. Return a registered Future + /// 3. Create a Future via reflection + /// + /// Parameters: + /// - [type]: Optional type parameter that overrides [T] if provided. + /// + /// Throws: + /// - ReflectionException if no suitable injection is found + Future makeAsync([Type? type]); + + /// Registers a singleton instance. + /// + /// The instance will be shared across the container hierarchy. + /// + /// Parameters: + /// - [object]: The singleton instance to register. + /// - [as]: Optional type to register the singleton as. + /// + /// Returns the registered instance. + /// + /// Throws: + /// - StateError if a singleton is already registered for the type + T registerSingleton(T object, {Type? as}); + + /// Registers a factory function. + /// + /// The factory will be called each time an instance is needed. + /// + /// Parameters: + /// - [factory]: Function that creates instances. + /// - [as]: Optional type to register the factory as. + /// + /// Returns the factory function. + /// + /// Throws: + /// - StateError if a factory is already registered for the type + T Function(ContainerContract) registerFactory( + T Function(ContainerContract) factory, + {Type? as}); + + /// Registers a lazy singleton. + /// + /// The singleton will be created on first use. + /// + /// Parameters: + /// - [factory]: Function that creates the singleton. + /// - [as]: Optional type to register the singleton as. + /// + /// Returns the factory function. + T Function(ContainerContract) registerLazySingleton( + T Function(ContainerContract) factory, + {Type? as}); + + /// Gets a named singleton. + /// + /// Parameters: + /// - [name]: The name of the singleton to retrieve. + /// + /// Returns the named singleton instance. + /// + /// Throws: + /// - StateError if no singleton exists with the given name + T findByName(String name); + + /// Registers a named singleton. + /// + /// Parameters: + /// - [name]: The name to register the singleton under. + /// - [object]: The singleton instance. + /// + /// Returns the registered instance. + /// + /// Throws: + /// - StateError if a singleton already exists with the given name + T registerNamedSingleton(String name, T object); +} diff --git a/packages/contracts/lib/src/container/contextual_binding_contract.dart b/packages/contracts/lib/src/container/contextual_binding_contract.dart new file mode 100644 index 0000000..7071c36 --- /dev/null +++ b/packages/contracts/lib/src/container/contextual_binding_contract.dart @@ -0,0 +1,42 @@ +import 'package:meta/meta.dart'; + +/// Contract for contextual binding in dependency injection. +/// +/// This contract defines the interface for creating contextual bindings, +/// allowing dependencies to be resolved differently based on context. +@sealed +abstract class ContextualBindingContract { + /// Specifies the concrete type that triggers this contextual binding. + /// + /// Parameters: + /// - [concrete]: The concrete type that needs dependencies. + /// + /// Returns a builder for specifying what type is needed. + ContextualNeedsContract when(Type concrete); +} + +/// Contract for specifying contextual needs. +/// +/// This contract defines the interface for specifying what type +/// is needed in a particular context. +@sealed +abstract class ContextualNeedsContract { + /// Specifies the type needed in this context. + /// + /// Returns a builder for specifying what to give. + ContextualGiveContract needs(); +} + +/// Contract for specifying contextual implementations. +/// +/// This contract defines the interface for specifying what +/// implementation to provide in a particular context. +@sealed +abstract class ContextualGiveContract { + /// Specifies what to give for this contextual binding. + /// + /// Parameters: + /// - [implementation]: The implementation to provide. + /// This can be an instance, a factory function, or a type. + void give(dynamic implementation); +} diff --git a/packages/contracts/lib/src/events/event_dispatcher_contract.dart b/packages/contracts/lib/src/events/event_dispatcher_contract.dart new file mode 100644 index 0000000..47e2308 --- /dev/null +++ b/packages/contracts/lib/src/events/event_dispatcher_contract.dart @@ -0,0 +1,199 @@ +import 'package:meta/meta.dart'; + +/// Contract for event dispatching functionality. +/// +/// This contract defines the interface for dispatching events, +/// managing listeners, and handling event broadcasting. +/// +/// The contract includes both Laravel-compatible methods and platform-specific +/// extensions for enhanced functionality. +@sealed +abstract class EventDispatcherContract { + /// Registers an event listener. + /// + /// Laravel-compatible: Registers event listeners, but with platform-specific + /// dynamic typing for more flexible event handling. + /// + /// Parameters: + /// - [events]: Event type or list of event types to listen for. + /// - [listener]: Function to handle the event. + void listen(dynamic events, dynamic listener); + + /// Checks if event has listeners. + /// + /// Platform-specific: Provides listener existence checking. + /// + /// Parameters: + /// - [eventName]: Name of the event to check. + bool hasListeners(String eventName); + + /// Pushes an event for delayed processing. + /// + /// Platform-specific: Supports delayed event processing. + /// + /// Parameters: + /// - [event]: Name of the event. + /// - [payload]: Optional event payload. + void push(String event, [dynamic payload]); + + /// Flushes delayed events. + /// + /// Platform-specific: Processes delayed events immediately. + /// + /// Parameters: + /// - [event]: Name of the event to flush. + Future flush(String event); + + /// Subscribes an event subscriber. + /// + /// Laravel-compatible: Registers event subscribers, but with platform-specific + /// dynamic typing for more flexible subscription handling. + /// + /// Parameters: + /// - [subscriber]: The subscriber to register. + void subscribe(dynamic subscriber); + + /// Waits for an event to occur. + /// + /// Platform-specific: Provides event waiting functionality. + /// + /// Parameters: + /// - [event]: Event to wait for. + /// - [payload]: Optional payload to dispatch. + Future until(dynamic event, [dynamic payload]); + + /// Dispatches an event. + /// + /// Laravel-compatible: Dispatches events, with platform-specific + /// extensions for halting and payload handling. + /// + /// Parameters: + /// - [event]: Event to dispatch. + /// - [payload]: Optional event payload. + /// - [halt]: Whether to halt after first handler. + Future dispatch(dynamic event, [dynamic payload, bool? halt]); + + /// Gets registered listeners. + /// + /// Laravel-compatible: Retrieves event listeners. + /// + /// Parameters: + /// - [eventName]: Name of the event. + List getListeners(String eventName); + + /// Removes an event listener. + /// + /// Laravel-compatible: Removes event listeners. + /// + /// Parameters: + /// - [event]: Event to remove listener for. + void forget(String event); + + /// Removes pushed event listeners. + /// + /// Platform-specific: Cleans up delayed event listeners. + void forgetPushed(); + + /// Sets queue resolver. + /// + /// Laravel-compatible: Configures queue integration. + /// + /// Parameters: + /// - [resolver]: Queue resolver function. + void setQueueResolver(Function resolver); + + /// Sets transaction manager resolver. + /// + /// Laravel-compatible: Configures transaction integration. + /// + /// Parameters: + /// - [resolver]: Transaction manager resolver function. + void setTransactionManagerResolver(Function resolver); + + /// Gets raw event listeners. + /// + /// Platform-specific: Provides access to raw listener data. + Map> getRawListeners(); +} + +/// Contract for event subscribers. +/// +/// Laravel-compatible: Defines how event subscribers register +/// their event handling methods. +@sealed +abstract class EventSubscriberContract { + /// Subscribes to events. + /// + /// Laravel-compatible: Returns event handler mappings. + /// + /// Returns a map of event types to handler functions. + Map subscribe(); +} + +/// Marker interface for broadcastable events. +/// +/// Laravel-compatible: Events implementing this interface will be broadcast +/// across the application. +@sealed +abstract class ShouldBroadcast { + /// Gets channels to broadcast on. + /// + /// Laravel-compatible: Defines broadcast channels. + List broadcastOn(); + + /// Gets event name for broadcasting. + /// + /// Laravel-compatible: Defines broadcast event name. + String broadcastAs() => runtimeType.toString(); + + /// Gets broadcast data. + /// + /// Laravel-compatible: Defines broadcast payload. + Map get broadcastWith => {}; +} + +/// Marker interface for queueable events. +/// +/// Laravel-compatible: Events implementing this interface will be processed +/// through the queue system. +@sealed +abstract class ShouldQueue { + /// Gets the queue name. + /// + /// Laravel-compatible: Defines target queue. + String get queue => 'default'; + + /// Gets the processing delay. + /// + /// Laravel-compatible: Defines queue delay. + Duration? get delay => null; + + /// Gets maximum retry attempts. + /// + /// Laravel-compatible: Defines retry limit. + int get tries => 1; +} + +/// Marker interface for encrypted events. +/// +/// Laravel-compatible: Events implementing this interface will be encrypted +/// before being stored or transmitted. +@sealed +abstract class ShouldBeEncrypted { + /// Whether the event should be encrypted. + /// + /// Laravel-compatible: Controls event encryption. + bool get shouldBeEncrypted => true; +} + +/// Marker interface for events that should dispatch after commit. +/// +/// Laravel-compatible: Events implementing this interface will only be dispatched +/// after the current database transaction commits. +@sealed +abstract class ShouldDispatchAfterCommit { + /// Whether to dispatch after commit. + /// + /// Laravel-compatible: Controls transaction-based dispatch. + bool get afterCommit => true; +} diff --git a/packages/contracts/lib/src/events/events.dart b/packages/contracts/lib/src/events/events.dart new file mode 100644 index 0000000..6f6e5c1 --- /dev/null +++ b/packages/contracts/lib/src/events/events.dart @@ -0,0 +1,2 @@ +/// Events package contracts +export 'event_dispatcher_contract.dart'; diff --git a/packages/contracts/lib/src/http/http.dart b/packages/contracts/lib/src/http/http.dart new file mode 100644 index 0000000..4fb3ab6 --- /dev/null +++ b/packages/contracts/lib/src/http/http.dart @@ -0,0 +1,2 @@ +/// HTTP package contracts +export 'http_contract.dart'; diff --git a/packages/contracts/lib/src/http/http_contract.dart b/packages/contracts/lib/src/http/http_contract.dart new file mode 100644 index 0000000..5f54ffa --- /dev/null +++ b/packages/contracts/lib/src/http/http_contract.dart @@ -0,0 +1,299 @@ +import 'package:meta/meta.dart'; + +/// Contract for HTTP requests. +/// +/// Laravel-compatible: Core request functionality matching Laravel's Request +/// interface, with platform-specific stream handling. +@sealed +abstract class RequestContract { + /// Gets the request method. + /// + /// Laravel-compatible: HTTP method accessor. + String get method; + + /// Gets the request URI. + /// + /// Laravel-compatible: Request URI using Dart's Uri class. + Uri get uri; + + /// Gets request headers. + /// + /// Laravel-compatible: Header access with platform-specific + /// multi-value support. + Map> get headers; + + /// Gets query parameters. + /// + /// Laravel-compatible: Query parameter access. + Map get query; + + /// Gets POST data. + /// + /// Laravel-compatible: POST data access. + Map get post; + + /// Gets cookies. + /// + /// Laravel-compatible: Cookie access. + Map get cookies; + + /// Gets uploaded files. + /// + /// Laravel-compatible: File upload handling with + /// platform-specific contract. + Map get files; + + /// Gets the request body. + /// + /// Platform-specific: Stream-based body access. + Stream> get body; + + /// Gets a request header. + /// + /// Laravel-compatible: Single header access. + String? header(String name, [String? defaultValue]); + + /// Gets a query parameter. + /// + /// Laravel-compatible: Single query parameter access. + String? query_(String name, [String? defaultValue]); + + /// Gets a POST value. + /// + /// Laravel-compatible: Single POST value access. + dynamic post_(String name, [dynamic defaultValue]); + + /// Gets a cookie value. + /// + /// Laravel-compatible: Single cookie access. + String? cookie(String name, [String? defaultValue]); + + /// Gets an uploaded file. + /// + /// Laravel-compatible: Single file access. + UploadedFileContract? file(String name); + + /// Gets all input data (query + post). + /// + /// Laravel-compatible: Combined input access. + Map all(); + + /// Gets input value from any source. + /// + /// Laravel-compatible: Universal input access. + dynamic input(String name, [dynamic defaultValue]); + + /// Checks if input exists. + /// + /// Laravel-compatible: Input existence check. + bool has(String name); + + /// Gets the raw request body as string. + /// + /// Platform-specific: Async text body access. + Future text(); + + /// Gets the request body as JSON. + /// + /// Platform-specific: Async JSON body access. + Future json(); +} + +/// Contract for HTTP responses. +/// +/// Laravel-compatible: Core response functionality matching Laravel's Response +/// interface, with platform-specific async features. +@sealed +abstract class ResponseContract { + /// Gets response headers. + /// + /// Laravel-compatible: Header access with platform-specific + /// multi-value support. + Map> get headers; + + /// Gets the status code. + /// + /// Laravel-compatible: Status code accessor. + int get status; + + /// Sets the status code. + /// + /// Laravel-compatible: Status code mutator. + set status(int value); + + /// Sets a response header. + /// + /// Laravel-compatible: Single header setting. + void header(String name, String value); + + /// Sets multiple headers. + /// + /// Laravel-compatible: Bulk header setting. + void headers_(Map headers); + + /// Sets a cookie. + /// + /// Laravel-compatible: Cookie setting with platform-specific + /// security options. + void cookie( + String name, + String value, { + Duration? maxAge, + DateTime? expires, + String? domain, + String? path, + bool secure = false, + bool httpOnly = false, + String? sameSite, + }); + + /// Writes response body content. + /// + /// Laravel-compatible: Content writing. + void write(dynamic content); + + /// Sends JSON response. + /// + /// Laravel-compatible: JSON response. + void json(dynamic data); + + /// Sends file download. + /// + /// Laravel-compatible: File download with platform-specific + /// async handling. + Future download(String path, [String? name]); + + /// Redirects to another URL. + /// + /// Laravel-compatible: Redirect response. + void redirect(String url, [int status = 302]); + + /// Sends the response. + /// + /// Platform-specific: Async response sending. + Future send(); +} + +/// Contract for uploaded files. +/// +/// Laravel-compatible: File upload handling matching Laravel's UploadedFile +/// interface, with platform-specific async operations. +@sealed +abstract class UploadedFileContract { + /// Gets the original client filename. + /// + /// Laravel-compatible: Original filename. + String get filename; + + /// Gets the file MIME type. + /// + /// Laravel-compatible: MIME type. + String get mimeType; + + /// Gets the file size in bytes. + /// + /// Laravel-compatible: File size. + int get size; + + /// Gets temporary file path. + /// + /// Laravel-compatible: Temporary storage. + String get path; + + /// Moves file to new location. + /// + /// Laravel-compatible: File movement with platform-specific + /// async handling. + Future moveTo(String path); + + /// Gets file contents as bytes. + /// + /// Platform-specific: Async binary content access. + Future> bytes(); + + /// Gets file contents as string. + /// + /// Platform-specific: Async text content access. + Future text(); +} + +/// Contract for HTTP middleware. +/// +/// Laravel-compatible: Middleware functionality matching Laravel's Middleware +/// interface, with platform-specific async handling. +@sealed +abstract class MiddlewareContract { + /// Handles the request. + /// + /// Laravel-compatible: Middleware handling with platform-specific + /// async processing. + /// + /// Parameters: + /// - [request]: The incoming request. + /// - [next]: Function to pass to next middleware. + Future handle(RequestContract request, + Future Function(RequestContract) next); +} + +/// Contract for HTTP kernel. +/// +/// Laravel-compatible: HTTP kernel functionality matching Laravel's HttpKernel +/// interface, with platform-specific async processing. +@sealed +abstract class HttpKernelContract { + /// Gets global middleware. + /// + /// Laravel-compatible: Global middleware list. + List get middleware; + + /// Gets middleware groups. + /// + /// Laravel-compatible: Middleware grouping. + Map> get middlewareGroups; + + /// Gets route middleware. + /// + /// Laravel-compatible: Route middleware mapping. + Map get routeMiddleware; + + /// Handles an HTTP request. + /// + /// Laravel-compatible: Request handling with platform-specific + /// async processing. + Future handle(RequestContract request); + + /// Terminates the request/response cycle. + /// + /// Laravel-compatible: Request termination with platform-specific + /// async processing. + Future terminate( + RequestContract request, ResponseContract response); +} + +/// Contract for HTTP context. +/// +/// Platform-specific: Provides request context beyond Laravel's +/// standard request handling. +@sealed +abstract class HttpContextContract { + /// Gets the current request. + RequestContract get request; + + /// Gets the current response. + ResponseContract get response; + + /// Gets context attributes. + Map get attributes; + + /// Gets a context attribute. + T? getAttribute(String key); + + /// Sets a context attribute. + void setAttribute(String key, dynamic value); + + /// Gets the route parameters. + Map get routeParams; + + /// Gets a route parameter. + T? getRouteParam(String name); +} diff --git a/packages/contracts/lib/src/model/model.dart b/packages/contracts/lib/src/model/model.dart new file mode 100644 index 0000000..9dd4228 --- /dev/null +++ b/packages/contracts/lib/src/model/model.dart @@ -0,0 +1,2 @@ +/// Model package contracts +export 'model_contract.dart'; diff --git a/packages/contracts/lib/src/model/model_contract.dart b/packages/contracts/lib/src/model/model_contract.dart new file mode 100644 index 0000000..b88fe12 --- /dev/null +++ b/packages/contracts/lib/src/model/model_contract.dart @@ -0,0 +1,148 @@ +import 'package:meta/meta.dart'; + +/// Contract for base model functionality. +/// +/// Laravel-compatible: Provides core model functionality similar to Laravel's +/// Model class, adapted for Dart's type system and patterns. +@sealed +abstract class ModelContract { + /// Gets the model's unique identifier. + /// + /// Laravel-compatible: Primary key accessor. + /// Extended with nullable String type for flexibility. + String? get id; + + /// Sets the model's unique identifier. + /// + /// Laravel-compatible: Primary key mutator. + /// Extended with nullable String type for flexibility. + set id(String? value); + + /// Gets the creation timestamp. + /// + /// Laravel-compatible: Created at timestamp accessor. + /// Uses Dart's DateTime instead of Carbon. + DateTime? get createdAt; + + /// Sets the creation timestamp. + /// + /// Laravel-compatible: Created at timestamp mutator. + /// Uses Dart's DateTime instead of Carbon. + set createdAt(DateTime? value); + + /// Gets the last update timestamp. + /// + /// Laravel-compatible: Updated at timestamp accessor. + /// Uses Dart's DateTime instead of Carbon. + DateTime? get updatedAt; + + /// Sets the last update timestamp. + /// + /// Laravel-compatible: Updated at timestamp mutator. + /// Uses Dart's DateTime instead of Carbon. + set updatedAt(DateTime? value); + + /// Gets the ID as an integer. + /// + /// Platform-specific: Provides integer ID conversion. + /// Returns -1 if ID is null or not a valid integer. + int get idAsInt; + + /// Gets the ID as a string. + /// + /// Platform-specific: Provides string ID conversion. + /// Returns empty string if ID is null. + String get idAsString; +} + +/// Contract for auditable model functionality. +/// +/// Laravel-compatible: Similar to Laravel's auditable trait, +/// providing user tracking for model changes. +@sealed +abstract class AuditableModelContract extends ModelContract { + /// Gets the ID of user who created the record. + /// + /// Laravel-compatible: Created by user tracking. + /// Uses String ID instead of user model reference. + String? get createdBy; + + /// Sets the ID of user who created the record. + /// + /// Laravel-compatible: Created by user tracking. + /// Uses String ID instead of user model reference. + set createdBy(String? value); + + /// Gets the ID of user who last updated the record. + /// + /// Laravel-compatible: Updated by user tracking. + /// Uses String ID instead of user model reference. + String? get updatedBy; + + /// Sets the ID of user who last updated the record. + /// + /// Laravel-compatible: Updated by user tracking. + /// Uses String ID instead of user model reference. + set updatedBy(String? value); +} + +/// Optional contract for model serialization. +/// +/// Laravel-compatible: Similar to Laravel's serialization features, +/// adapted for Dart's type system. +@sealed +abstract class SerializableModelContract { + /// Converts model to a map. + /// + /// Laravel-compatible: Similar to toArray() method. + Map toMap(); + + /// Creates model from a map. + /// + /// Laravel-compatible: Similar to fill() method. + void fromMap(Map map); +} + +/// Optional contract for model validation. +/// +/// Platform-specific: Provides built-in validation support, +/// inspired by Laravel's validation but adapted for Dart. +@sealed +abstract class ValidatableModelContract { + /// Validates the model. + /// + /// Platform-specific: Returns validation errors if invalid. + Map>? validate(); + + /// Gets validation rules. + /// + /// Platform-specific: Defines validation rules. + Map> get rules; + + /// Gets custom error messages. + /// + /// Platform-specific: Defines custom validation messages. + Map get messages; +} + +/// Optional contract for model events. +/// +/// Laravel-compatible: Similar to Laravel's model events, +/// adapted for Dart's event system. +@sealed +abstract class ObservableModelContract { + /// Gets the event name. + /// + /// Laravel-compatible: Defines event identifier. + String get eventName; + + /// Gets the event timestamp. + /// + /// Platform-specific: Adds timestamp tracking to events. + DateTime get eventTimestamp; + + /// Gets event data. + /// + /// Laravel-compatible: Provides event payload. + Map get eventData; +} diff --git a/packages/contracts/lib/src/pipeline/pipeline.dart b/packages/contracts/lib/src/pipeline/pipeline.dart new file mode 100644 index 0000000..a834069 --- /dev/null +++ b/packages/contracts/lib/src/pipeline/pipeline.dart @@ -0,0 +1,2 @@ +/// Pipeline package contracts +export 'pipeline_contract.dart'; diff --git a/packages/contracts/lib/src/pipeline/pipeline_contract.dart b/packages/contracts/lib/src/pipeline/pipeline_contract.dart new file mode 100644 index 0000000..1e2f8db --- /dev/null +++ b/packages/contracts/lib/src/pipeline/pipeline_contract.dart @@ -0,0 +1,127 @@ +import 'package:meta/meta.dart'; + +/// Contract for a pipe that processes objects in a pipeline. +/// +/// Laravel-compatible: Core pipe functionality matching Laravel's +/// pipe interface, with platform-specific async handling. +@sealed +abstract class PipeContract { + /// Handles the passable object. + /// + /// Laravel-compatible: Core pipe handling with platform-specific + /// async processing. + /// + /// Parameters: + /// - [passable]: The object being passed through the pipeline. + /// - [next]: Function to pass the object to the next pipe. + /// + /// Returns the processed object, possibly modified. + Future handle( + dynamic passable, Future Function(dynamic) next); +} + +/// Contract for a pipeline that processes objects through a series of pipes. +/// +/// Laravel-compatible: Core pipeline functionality matching Laravel's +/// Pipeline class, with platform-specific fluent interface. +@sealed +abstract class PipelineContract { + /// Sets the object to be passed through the pipeline. + /// + /// Laravel-compatible: Pipeline input setting. + /// + /// Parameters: + /// - [passable]: The object to process. + /// + /// Returns the pipeline instance for fluent chaining. + PipelineContract send(dynamic passable); + + /// Sets the array of pipes to process the object through. + /// + /// Laravel-compatible: Pipe configuration with platform-specific + /// flexibility for pipe types. + /// + /// Parameters: + /// - [pipes]: The pipes to process the object through. + /// Can be a single pipe or an iterable of pipes. + /// + /// Returns the pipeline instance for fluent chaining. + PipelineContract through(dynamic pipes); + + /// Adds additional pipes to the pipeline. + /// + /// Platform-specific: Additional method for pipe configuration + /// following Laravel's fluent pattern. + /// + /// Parameters: + /// - [pipes]: The pipes to add. + /// Can be a single pipe or an iterable of pipes. + /// + /// Returns the pipeline instance for fluent chaining. + PipelineContract pipe(dynamic pipes); + + /// Sets the method to call on the pipes. + /// + /// Laravel-compatible: Method name configuration. + /// + /// Parameters: + /// - [method]: The name of the method to call. + /// + /// Returns the pipeline instance for fluent chaining. + PipelineContract via(String method); + + /// Runs the pipeline with a final destination callback. + /// + /// Laravel-compatible: Pipeline execution with platform-specific + /// async processing. + /// + /// Parameters: + /// - [destination]: Function to process the final result. + /// + /// Returns the processed result. + Future then(dynamic Function(dynamic) destination); + + /// Runs the pipeline and returns the result. + /// + /// Platform-specific: Direct result access following Laravel's + /// pipeline execution pattern. + /// + /// Returns the processed object directly. + Future thenReturn(); +} + +/// Contract for a pipeline hub that manages multiple pipelines. +/// +/// Laravel-compatible: Pipeline management functionality matching +/// Laravel's pipeline hub features. +@sealed +abstract class PipelineHubContract { + /// Gets or creates a pipeline with the given name. + /// + /// Laravel-compatible: Named pipeline access. + /// + /// Parameters: + /// - [name]: The name of the pipeline. + /// + /// Returns the pipeline instance. + PipelineContract pipeline(String name); + + /// Sets the default pipes for a pipeline. + /// + /// Laravel-compatible: Default pipe configuration. + /// + /// Parameters: + /// - [name]: The name of the pipeline. + /// - [pipes]: The default pipes for the pipeline. + void defaults(String name, List pipes); + + /// Registers a pipe type with a name. + /// + /// Platform-specific: Named pipe type registration following + /// Laravel's service registration pattern. + /// + /// Parameters: + /// - [name]: The name to register the pipe type under. + /// - [type]: The pipe type to register. + void registerPipeType(String name, Type type); +} diff --git a/packages/contracts/lib/src/process/process.dart b/packages/contracts/lib/src/process/process.dart new file mode 100644 index 0000000..4155b10 --- /dev/null +++ b/packages/contracts/lib/src/process/process.dart @@ -0,0 +1,2 @@ +/// Process package contracts +export 'process_contract.dart'; diff --git a/packages/contracts/lib/src/process/process_contract.dart b/packages/contracts/lib/src/process/process_contract.dart new file mode 100644 index 0000000..afe9824 --- /dev/null +++ b/packages/contracts/lib/src/process/process_contract.dart @@ -0,0 +1,251 @@ +import 'dart:async'; +import 'dart:io'; +import 'package:meta/meta.dart'; + +/// Contract for process management. +/// +/// Platform-specific: Provides system process management following Laravel's +/// architectural patterns for resource management and lifecycle control. +@sealed +abstract class ProcessManagerContract { + /// Starts a new process. + /// + /// Platform-specific: Creates and starts a new system process with + /// Laravel-style identifier and configuration options. + /// + /// Parameters: + /// - [id]: Unique identifier for the process. + /// - [command]: Command to execute. + /// - [arguments]: Command arguments. + /// - [workingDirectory]: Optional working directory. + /// - [environment]: Optional environment variables. + /// - [timeout]: Optional execution timeout. + /// - [tty]: Whether to run in a terminal. + /// - [enableReadError]: Whether to enable error stream reading. + Future start( + String id, + String command, + List arguments, { + String? workingDirectory, + Map? environment, + Duration? timeout, + bool tty = false, + bool enableReadError = true, + }); + + /// Gets a running process by ID. + /// + /// Platform-specific: Retrieves process by identifier, + /// following Laravel's repository pattern. + ProcessContract? get(String id); + + /// Kills a process. + /// + /// Platform-specific: Terminates a process with optional signal, + /// following Laravel's resource cleanup patterns. + /// + /// Parameters: + /// - [id]: Process ID to kill. + /// - [signal]: Signal to send (default: SIGTERM). + Future kill(String id, {ProcessSignal signal = ProcessSignal.sigterm}); + + /// Kills all managed processes. + /// + /// Platform-specific: Bulk process termination, + /// following Laravel's collection operation patterns. + Future killAll({ProcessSignal signal = ProcessSignal.sigterm}); + + /// Gets process events stream. + /// + /// Platform-specific: Event streaming following Laravel's + /// event broadcasting patterns. + Stream get events; + + /// Runs processes in a pool. + /// + /// Platform-specific: Concurrent process execution following + /// Laravel's job queue worker pool patterns. + /// + /// Parameters: + /// - [processes]: Processes to run. + /// - [concurrency]: Max concurrent processes. + Future> pool( + List processes, { + int concurrency = 5, + }); + + /// Runs processes in a pipeline. + /// + /// Platform-specific: Sequential process execution following + /// Laravel's pipeline pattern. + Future pipeline(List processes); + + /// Disposes the manager and all processes. + /// + /// Platform-specific: Resource cleanup following Laravel's + /// service provider cleanup patterns. + void dispose(); +} + +/// Contract for process instances. +/// +/// Platform-specific: Defines individual process behavior following +/// Laravel's resource management patterns. +@sealed +abstract class ProcessContract { + /// Gets the process command. + String get command; + + /// Gets the process ID. + int? get pid; + + /// Gets process start time. + DateTime? get startTime; + + /// Gets process end time. + DateTime? get endTime; + + /// Gets process output stream. + Stream> get output; + + /// Gets process error stream. + Stream> get errorOutput; + + /// Gets process exit code. + Future get exitCode; + + /// Whether the process is running. + bool get isRunning; + + /// Starts the process. + Future start(); + + /// Runs the process to completion. + Future run(); + + /// Runs the process with a timeout. + /// + /// Parameters: + /// - [timeout]: Maximum execution time. + /// + /// Throws TimeoutException if process exceeds timeout. + Future runWithTimeout(Duration timeout); + + /// Writes input to the process. + Future write(String input); + + /// Writes multiple lines to the process. + Future writeLines(List lines); + + /// Kills the process. + Future kill({ProcessSignal signal = ProcessSignal.sigterm}); + + /// Sends a signal to the process. + bool sendSignal(ProcessSignal signal); + + /// Gets process output as string. + Future get outputAsString; + + /// Gets process error output as string. + Future get errorOutputAsString; + + /// Disposes the process. + Future dispose(); +} + +/// Contract for process results. +/// +/// Platform-specific: Defines process execution results following +/// Laravel's response/result patterns. +@sealed +abstract class ProcessResultContract { + /// Gets the process ID. + int get pid; + + /// Gets the exit code. + int get exitCode; + + /// Gets the process output. + String get output; + + /// Gets the process error output. + String get errorOutput; + + /// Gets string representation. + @override + String toString() { + return 'ProcessResult(pid: $pid, exitCode: $exitCode, output: ${output.length} chars, errorOutput: ${errorOutput.length} chars)'; + } +} + +/// Contract for process events. +/// +/// Platform-specific: Defines process lifecycle events following +/// Laravel's event system patterns. +@sealed +abstract class ProcessEventContract { + /// Gets the process ID. + String get id; + + /// Gets the event timestamp. + DateTime get timestamp; +} + +/// Contract for process started events. +/// +/// Platform-specific: Defines process start event following +/// Laravel's event naming and structure patterns. +@sealed +abstract class ProcessStartedEventContract extends ProcessEventContract { + /// Gets the started process. + ProcessContract get process; + + @override + String toString() => + 'ProcessStartedEvent(id: $id, command: ${process.command})'; +} + +/// Contract for process exited events. +/// +/// Platform-specific: Defines process exit event following +/// Laravel's event naming and structure patterns. +@sealed +abstract class ProcessExitedEventContract extends ProcessEventContract { + /// Gets the exit code. + int get exitCode; + + @override + String toString() => 'ProcessExitedEvent(id: $id, exitCode: $exitCode)'; +} + +/// Contract for process pools. +/// +/// Platform-specific: Defines concurrent process execution following +/// Laravel's worker pool patterns. +@sealed +abstract class ProcessPoolContract { + /// Gets maximum concurrent processes. + int get concurrency; + + /// Gets active processes. + List get active; + + /// Gets pending processes. + List get pending; + + /// Runs processes in the pool. + Future> run(List processes); +} + +/// Contract for process pipelines. +/// +/// Platform-specific: Defines sequential process execution following +/// Laravel's pipeline pattern. +@sealed +abstract class ProcessPipelineContract { + /// Gets pipeline processes. + List get processes; + + /// Runs the pipeline. + Future run(); +} diff --git a/packages/contracts/lib/src/queue/queue.dart b/packages/contracts/lib/src/queue/queue.dart new file mode 100644 index 0000000..2501fd2 --- /dev/null +++ b/packages/contracts/lib/src/queue/queue.dart @@ -0,0 +1,2 @@ +/// Queue package contracts +export 'queue_contract.dart'; diff --git a/packages/contracts/lib/src/queue/queue_contract.dart b/packages/contracts/lib/src/queue/queue_contract.dart new file mode 100644 index 0000000..94c0a55 --- /dev/null +++ b/packages/contracts/lib/src/queue/queue_contract.dart @@ -0,0 +1,284 @@ +import 'package:meta/meta.dart'; + +/// Contract for queue operations. +/// +/// Laravel-compatible: Core queue functionality matching Laravel's Queue +/// interface, adapted for Dart's type system and async patterns. +@sealed +abstract class QueueContract { + /// Pushes a job onto the queue. + /// + /// Laravel-compatible: Core push method. + /// Uses dynamic job type for flexibility. + Future push(dynamic job, [String? queue]); + + /// Pushes a job onto a specific queue. + /// + /// Laravel-compatible: Queue-specific push. + /// Uses dynamic job type for flexibility. + Future pushOn(String queue, dynamic job); + + /// Pushes a delayed job onto the queue. + /// + /// Laravel-compatible: Delayed job push. + /// Uses Duration instead of DateTime/Carbon. + Future later(Duration delay, dynamic job, [String? queue]); + + /// Pushes a delayed job onto a specific queue. + /// + /// Laravel-compatible: Queue-specific delayed push. + /// Uses Duration instead of DateTime/Carbon. + Future laterOn(String queue, Duration delay, dynamic job); + + /// Pushes multiple jobs onto the queue. + /// + /// Laravel-compatible: Bulk job push. + /// Uses dynamic job type for flexibility. + Future bulk(List jobs, [String? queue]); + + /// Gets the next job from the queue. + /// + /// Laravel-compatible: Job pop operation. + Future pop([String? queue]); + + /// Creates a job batch. + /// + /// Laravel-compatible: Batch creation. + BatchContract batch(List jobs); + + /// Gets a queue connection. + /// + /// Laravel-compatible: Connection retrieval. + QueueConnectionContract connection([String? name]); +} + +/// Contract for queue jobs. +/// +/// Laravel-compatible: Core job interface matching Laravel's Job +/// contract, with platform-specific extensions. +@sealed +abstract class JobContract { + /// Gets the job ID. + /// + /// Laravel-compatible: Job identifier. + String get id; + + /// Gets the job payload. + /// + /// Laravel-compatible: Job data. + Map get payload; + + /// Gets the number of attempts. + /// + /// Laravel-compatible: Attempt tracking. + int get attempts; + + /// Gets the maximum number of tries. + /// + /// Laravel-compatible: Retry limit. + int get tries; + + /// Gets the job timeout in seconds. + /// + /// Laravel-compatible: Timeout configuration. + int get timeout; + + /// Gets the queue name. + /// + /// Laravel-compatible: Queue designation. + String? get queue; + + /// Gets the job delay. + /// + /// Laravel-compatible: Delay configuration. + /// Uses Duration instead of DateTime/Carbon. + Duration? get delay; + + /// Whether the job should be encrypted. + /// + /// Platform-specific: Adds encryption support. + bool get shouldBeEncrypted; + + /// Whether to dispatch after commit. + /// + /// Laravel-compatible: Transaction support. + bool get afterCommit; + + /// Executes the job. + /// + /// Laravel-compatible: Core job execution. + Future handle(); + + /// Handles job failure. + /// + /// Laravel-compatible: Failure handling. + Future failed([Exception? exception]); + + /// Releases the job back to the queue. + /// + /// Laravel-compatible: Job release. + /// Uses Duration instead of DateTime/Carbon. + Future release([Duration? delay]); + + /// Deletes the job. + /// + /// Laravel-compatible: Job deletion. + Future delete(); +} + +/// Contract for job batches. +/// +/// Laravel-compatible: Batch operations matching Laravel's batch +/// functionality, with platform-specific extensions. +@sealed +abstract class BatchContract { + /// Gets the batch ID. + /// + /// Laravel-compatible: Batch identifier. + String get id; + + /// Gets the jobs in the batch. + /// + /// Laravel-compatible: Batch jobs. + List get jobs; + + /// Adds jobs to the batch. + /// + /// Laravel-compatible: Job addition. + void add(List jobs); + + /// Dispatches the batch. + /// + /// Laravel-compatible: Batch dispatch. + Future dispatch(); + + /// Allows failures in the batch. + /// + /// Laravel-compatible: Failure configuration. + BatchContract allowFailures(); + + /// Sets the batch name. + /// + /// Laravel-compatible: Batch naming. + BatchContract name(String name); + + /// Adds a callback when all jobs finish. + /// + /// Laravel-compatible: Success callback. + BatchContract then(void Function(BatchContract) callback); + + /// Adds a callback when the batch fails. + /// + /// Laravel-compatible: Error callback. + BatchContract onError(void Function(BatchContract, dynamic) callback); + + /// Gets the batch progress. + /// + /// Platform-specific: Progress tracking. + double get progress; + + /// Gets finished job count. + /// + /// Platform-specific: Completion tracking. + int get finished; + + /// Gets failed job count. + /// + /// Platform-specific: Failure tracking. + int get failed; + + /// Gets pending job count. + /// + /// Platform-specific: Pending tracking. + int get pending; + + /// Gets total job count. + /// + /// Platform-specific: Size tracking. + int get total; +} + +/// Contract for queue connections. +/// +/// Laravel-compatible: Connection management matching Laravel's +/// queue connection functionality. +@sealed +abstract class QueueConnectionContract { + /// Gets the connection name. + /// + /// Laravel-compatible: Connection identifier. + String get name; + + /// Gets the connection driver. + /// + /// Laravel-compatible: Driver type. + String get driver; + + /// Gets the connection config. + /// + /// Laravel-compatible: Configuration access. + Map get config; + + /// Pushes a job onto the queue. + /// + /// Laravel-compatible: Job push. + Future push(dynamic job, [String? queue]); + + /// Gets the next job from the queue. + /// + /// Laravel-compatible: Job pop. + Future pop([String? queue]); + + /// Gets queue size. + /// + /// Laravel-compatible: Size check. + Future size([String? queue]); + + /// Clears the queue. + /// + /// Laravel-compatible: Queue clear. + Future clear([String? queue]); + + /// Pauses job processing. + /// + /// Laravel-compatible: Processing pause. + Future pause([String? queue]); + + /// Resumes job processing. + /// + /// Laravel-compatible: Processing resume. + Future resume([String? queue]); +} + +/// Contract for queue manager. +/// +/// Laravel-compatible: Manager functionality matching Laravel's +/// queue manager interface. +@sealed +abstract class QueueManagerContract { + /// Gets a queue connection. + /// + /// Laravel-compatible: Connection retrieval. + QueueConnectionContract connection([String? name]); + + /// Gets the default connection name. + /// + /// Laravel-compatible: Default connection. + String get defaultConnection; + + /// Sets the default connection name. + /// + /// Laravel-compatible: Default connection. + set defaultConnection(String name); + + /// Gets connection configuration. + /// + /// Laravel-compatible: Config access. + Map getConfig(String name); + + /// Extends available drivers. + /// + /// Laravel-compatible: Driver extension. + void extend(String driver, + QueueConnectionContract Function(Map) callback); +} diff --git a/packages/contracts/lib/src/reflection/reflection.dart b/packages/contracts/lib/src/reflection/reflection.dart new file mode 100644 index 0000000..5d24e43 --- /dev/null +++ b/packages/contracts/lib/src/reflection/reflection.dart @@ -0,0 +1,2 @@ +/// Reflection package contracts +export 'reflector_contract.dart'; diff --git a/packages/contracts/lib/src/reflection/reflector_contract.dart b/packages/contracts/lib/src/reflection/reflector_contract.dart new file mode 100644 index 0000000..7d53a25 --- /dev/null +++ b/packages/contracts/lib/src/reflection/reflector_contract.dart @@ -0,0 +1,148 @@ +import 'package:meta/meta.dart'; + +/// Contract for reflected type parameters +@sealed +abstract class ReflectedTypeParameterContract { + /// Gets the name of the type parameter + String get name; +} + +/// Contract for reflected types +@sealed +abstract class ReflectedTypeContract { + /// Gets the name of the type + String get name; + + /// Gets the type parameters if the type is generic + List get typeParameters; + + /// Gets the actual Dart type being reflected + Type get reflectedType; + + /// Checks if this type is assignable to another type + bool isAssignableTo(ReflectedTypeContract? other); + + /// Creates a new instance of this type + ReflectedInstanceContract newInstance( + String constructorName, List positionalArguments, + [Map namedArguments = const {}, + List typeArguments = const []]); +} + +/// Contract for reflected parameters +@sealed +abstract class ReflectedParameterContract { + /// Gets the parameter name + String get name; + + /// Gets the parameter annotations + List get annotations; + + /// Gets the parameter type + ReflectedTypeContract get type; + + /// Whether the parameter is required + bool get isRequired; + + /// Whether the parameter is named + bool get isNamed; +} + +/// Contract for reflected functions +@sealed +abstract class ReflectedFunctionContract { + /// Gets the function name + String get name; + + /// Gets the function's type parameters + List get typeParameters; + + /// Gets the function's annotations + List get annotations; + + /// Gets the function's return type + ReflectedTypeContract? get returnType; + + /// Gets the function's parameters + List get parameters; + + /// Whether the function is a getter + bool get isGetter; + + /// Whether the function is a setter + bool get isSetter; + + /// Invokes the function + ReflectedInstanceContract invoke(Invocation invocation); +} + +/// Contract for reflected declarations +@sealed +abstract class ReflectedDeclarationContract { + /// Gets the declaration name + String get name; + + /// Whether the declaration is static + bool get isStatic; + + /// Gets the associated function if any + ReflectedFunctionContract? get function; +} + +/// Contract for reflected classes +@sealed +abstract class ReflectedClassContract extends ReflectedTypeContract { + /// Gets the class annotations + List get annotations; + + /// Gets the class constructors + List get constructors; + + /// Gets the class declarations + List get declarations; +} + +/// Contract for reflected instances +@sealed +abstract class ReflectedInstanceContract { + /// Gets the instance type + ReflectedTypeContract get type; + + /// Gets the instance class + ReflectedClassContract get clazz; + + /// Gets the actual instance being reflected + Object? get reflectee; + + /// Gets a field value + ReflectedInstanceContract getField(String name); +} + +/// Core reflector contract for type introspection. +/// +/// This contract defines the interface for reflection capabilities, +/// allowing runtime inspection and manipulation of types, classes, +/// functions, and instances. +@sealed +abstract class ReflectorContract { + /// Gets the name from a symbol + String? getName(Symbol symbol); + + /// Reflects a class type + ReflectedClassContract? reflectClass(Type clazz); + + /// Reflects a function + ReflectedFunctionContract? reflectFunction(Function function); + + /// Reflects a type + ReflectedTypeContract? reflectType(Type type); + + /// Reflects an instance + ReflectedInstanceContract? reflectInstance(Object object); + + /// Reflects the Future of a type + /// + /// Throws: + /// - UnsupportedError if dart:mirrors is not available + ReflectedTypeContract reflectFutureOf(Type type); +} diff --git a/packages/contracts/lib/src/routing/routing.dart b/packages/contracts/lib/src/routing/routing.dart new file mode 100644 index 0000000..af283b4 --- /dev/null +++ b/packages/contracts/lib/src/routing/routing.dart @@ -0,0 +1,2 @@ +/// Routing package contracts +export 'routing_contract.dart'; diff --git a/packages/contracts/lib/src/routing/routing_contract.dart b/packages/contracts/lib/src/routing/routing_contract.dart new file mode 100644 index 0000000..684e7eb --- /dev/null +++ b/packages/contracts/lib/src/routing/routing_contract.dart @@ -0,0 +1,260 @@ +import 'package:meta/meta.dart'; + +/// Contract for router functionality. +/// +/// Laravel-compatible: Core routing functionality matching Laravel's Router +/// interface, with platform-specific generic type support. +@sealed +abstract class RouterContract { + /// Adds a route that responds to any HTTP method. + /// + /// Laravel-compatible: Any-method route registration. + RouteContract any(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to GET requests. + /// + /// Laravel-compatible: GET route registration. + RouteContract get(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to POST requests. + /// + /// Laravel-compatible: POST route registration. + RouteContract post(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to PUT requests. + /// + /// Laravel-compatible: PUT route registration. + RouteContract put(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to DELETE requests. + /// + /// Laravel-compatible: DELETE route registration. + RouteContract delete(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to PATCH requests. + /// + /// Laravel-compatible: PATCH route registration. + RouteContract patch(String path, T handler, + {Iterable middleware = const []}); + + /// Adds a route that responds to OPTIONS requests. + /// + /// Laravel-compatible: OPTIONS route registration. + RouteContract options(String path, T handler, + {Iterable middleware = const []}); + + /// Creates a route group with shared attributes. + /// + /// Laravel-compatible: Route grouping with platform-specific + /// callback-based configuration. + /// + /// Parameters: + /// - [path]: The prefix path for the group. + /// - [callback]: Function to define routes within the group. + /// - [middleware]: Middleware to apply to all routes in the group. + void group(String path, void Function(RouterContract router) callback, + {Iterable middleware = const []}); + + /// Mounts another router at a path prefix. + /// + /// Platform-specific: Provides router composition functionality. + /// + /// Parameters: + /// - [path]: The path to mount at. + /// - [router]: The router to mount. + void mount(String path, RouterContract router); + + /// Resolves a route for a request. + /// + /// Laravel-compatible: Route matching with platform-specific + /// match result contract. + /// + /// Parameters: + /// - [method]: The HTTP method. + /// - [path]: The request path. + RouteMatchContract? resolve(String method, String path); +} + +/// Contract for route definitions. +/// +/// Laravel-compatible: Route definition interface matching Laravel's Route +/// class, with platform-specific enhancements. +@sealed +abstract class RouteContract { + /// Gets the route path pattern. + /// + /// Laravel-compatible: Route URI pattern. + String get path; + + /// Gets the HTTP method this route responds to. + /// + /// Laravel-compatible: HTTP method. + String get method; + + /// Gets the route handler. + /// + /// Laravel-compatible: Route action with generic typing. + T get handler; + + /// Gets the route middleware. + /// + /// Laravel-compatible: Route middleware. + Iterable get middleware; + + /// Gets the route name. + /// + /// Laravel-compatible: Route name accessor. + String? get name; + + /// Sets the route name. + /// + /// Laravel-compatible: Route name mutator. + set name(String? value); + + /// Gets the route parameters. + /// + /// Laravel-compatible: Route parameters. + Map get parameters; + + /// Makes a URI for this route. + /// + /// Laravel-compatible: URL generation. + /// + /// Parameters: + /// - [params]: The parameter values to use. + String makeUri(Map params); + + /// Gets the route's regular expression pattern. + /// + /// Platform-specific: Direct access to route pattern. + RegExp get pattern; + + /// Whether the route matches a path. + /// + /// Platform-specific: Direct path matching. + bool matches(String path); +} + +/// Contract for route matching results. +/// +/// Platform-specific: Defines detailed match results beyond +/// Laravel's basic route matching. +@sealed +abstract class RouteMatchContract { + /// Gets the matched route. + RouteContract get route; + + /// Gets the matched parameters. + Map get params; + + /// Gets any remaining path after the match. + String get remaining; + + /// Gets the full matched path. + String get matched; +} + +/// Contract for route parameters. +/// +/// Laravel-compatible: Parameter handling matching Laravel's +/// parameter constraints, with platform-specific validation. +@sealed +abstract class RouteParameterContract { + /// Gets the parameter name. + String get name; + + /// Gets the parameter pattern. + String? get pattern; + + /// Whether the parameter is optional. + bool get isOptional; + + /// Gets the default value. + dynamic get defaultValue; + + /// Validates a parameter value. + bool validate(String value); +} + +/// Contract for route collection. +/// +/// Laravel-compatible: Route collection functionality matching +/// Laravel's RouteCollection, with platform-specific enhancements. +@sealed +abstract class RouteCollectionContract { + /// Gets all routes. + /// + /// Laravel-compatible: Route listing. + Iterable> get routes; + + /// Gets routes by method. + /// + /// Laravel-compatible: Method filtering. + Iterable> getByMethod(String method); + + /// Gets a route by name. + /// + /// Laravel-compatible: Named route lookup. + RouteContract? getByName(String name); + + /// Adds a route to the collection. + /// + /// Laravel-compatible: Route registration. + void add(RouteContract route); + + /// Removes a route from the collection. + /// + /// Laravel-compatible: Route removal. + void remove(RouteContract route); + + /// Gets routes with a specific middleware. + /// + /// Platform-specific: Middleware filtering. + Iterable> getByMiddleware(T middleware); +} + +/// Contract for route groups. +/// +/// Laravel-compatible: Route grouping functionality matching +/// Laravel's route group features, with platform-specific additions. +@sealed +abstract class RouteGroupContract { + /// Gets the group prefix. + /// + /// Laravel-compatible: Group prefix. + String get prefix; + + /// Gets the group middleware. + /// + /// Laravel-compatible: Group middleware. + Iterable get middleware; + + /// Gets the group namespace. + /// + /// Laravel-compatible: Group namespace. + String? get namespace; + + /// Gets routes in this group. + /// + /// Laravel-compatible: Group routes. + Iterable> get routes; + + /// Adds a route to the group. + /// + /// Laravel-compatible: Route addition with platform-specific + /// middleware support. + RouteContract addRoute(String method, String path, T handler, + {Iterable middleware = const []}); + + /// Creates a sub-group. + /// + /// Laravel-compatible: Nested grouping with platform-specific + /// namespace support. + RouteGroupContract group(String prefix, + {Iterable middleware = const [], String? namespace}); +} diff --git a/packages/contracts/lib/src/support/support.dart b/packages/contracts/lib/src/support/support.dart new file mode 100644 index 0000000..d8e5ba5 --- /dev/null +++ b/packages/contracts/lib/src/support/support.dart @@ -0,0 +1,2 @@ +/// Support package contracts +export 'support_contract.dart'; diff --git a/packages/contracts/lib/src/support/support_contract.dart b/packages/contracts/lib/src/support/support_contract.dart new file mode 100644 index 0000000..2f06ed0 --- /dev/null +++ b/packages/contracts/lib/src/support/support_contract.dart @@ -0,0 +1,263 @@ +import 'package:meta/meta.dart'; + +/// Contract for service providers. +/// +/// Laravel-compatible: Core service provider functionality matching +/// Laravel's ServiceProvider class, adapted for Dart's type system. +@sealed +abstract class ServiceProviderContract { + /// Registers application services. + /// + /// Laravel-compatible: Core registration method. + void register(); + + /// Bootstraps application services. + /// + /// Laravel-compatible: Core bootstrap method. + void boot(); + + /// Gets services provided by this provider. + /// + /// Laravel-compatible: Lists provided services. + List provides(); + + /// Gets events that trigger registration. + /// + /// Laravel-compatible: Lists registration triggers. + List when(); + + /// Whether provider is deferred. + /// + /// Laravel-compatible: Controls lazy loading. + bool isDeferred(); + + /// Gets the application instance. + /// + /// Laravel-compatible: Application access. + /// Uses dynamic type for flexibility. + dynamic get app; + + /// Sets the application instance. + /// + /// Laravel-compatible: Application injection. + /// Uses dynamic type for flexibility. + set app(dynamic value); + + /// Gets booting callbacks. + /// + /// Laravel-compatible: Boot phase callbacks. + List get bootingCallbacks; + + /// Gets booted callbacks. + /// + /// Laravel-compatible: Post-boot callbacks. + List get bootedCallbacks; + + /// Registers a booting callback. + /// + /// Laravel-compatible: Boot phase hook. + void booting(Function callback); + + /// Registers a booted callback. + /// + /// Laravel-compatible: Post-boot hook. + void booted(Function callback); + + /// Calls booting callbacks. + /// + /// Laravel-compatible: Executes boot phase hooks. + void callBootingCallbacks(); + + /// Calls booted callbacks. + /// + /// Laravel-compatible: Executes post-boot hooks. + void callBootedCallbacks(); + + /// Merges configuration. + /// + /// Laravel-compatible: Config merging. + void mergeConfigFrom(String path, String key); + + /// Replaces configuration recursively. + /// + /// Laravel-compatible: Deep config replacement. + void replaceConfigRecursivelyFrom(String path, String key); + + /// Loads routes from file. + /// + /// Laravel-compatible: Route loading. + void loadRoutesFrom(String path); + + /// Loads views from directory. + /// + /// Laravel-compatible: View loading. + void loadViewsFrom(String path, String namespace); + + /// Loads view components. + /// + /// Laravel-compatible: Component loading. + void loadViewComponentsAs(String prefix, List components); + + /// Loads translations from directory. + /// + /// Laravel-compatible: Translation loading. + void loadTranslationsFrom(String path, String namespace); + + /// Loads JSON translations. + /// + /// Laravel-compatible: JSON translation loading. + void loadJsonTranslationsFrom(String path); + + /// Loads database migrations. + /// + /// Laravel-compatible: Migration loading. + void loadMigrationsFrom(dynamic paths); + + /// Loads model factories. + /// + /// Laravel-compatible: Factory loading. + @Deprecated('Will be removed in a future version.') + void loadFactoriesFrom(dynamic paths); + + /// Sets up after resolving listener. + /// + /// Laravel-compatible: Resolution hook. + void callAfterResolving(String name, Function callback); + + /// Publishes migrations. + /// + /// Laravel-compatible: Migration publishing. + void publishesMigrations(List paths, [dynamic groups]); + + /// Registers publishable paths. + /// + /// Laravel-compatible: Asset publishing. + void registerPublishables(Map paths, [dynamic groups]); + + /// Legacy method for registering publishables. + /// + /// Laravel-compatible: Legacy publish method. + @Deprecated('Use registerPublishables instead') + void publishes(Map paths, [dynamic groups]); + + /// Initializes publish array. + /// + /// Laravel-compatible: Publish setup. + void ensurePublishArrayInitialized(String className); + + /// Adds a publish group. + /// + /// Laravel-compatible: Group publishing. + void addPublishGroup(String group, Map paths); + + /// Gets paths to publish. + /// + /// Laravel-compatible: Publish path lookup. + Map pathsToPublish([String? provider, String? group]); + + /// Gets paths for provider or group. + /// + /// Laravel-compatible: Provider/group path lookup. + Map pathsForProviderOrGroup(String? provider, String? group); + + /// Gets paths for provider and group. + /// + /// Laravel-compatible: Combined path lookup. + Map pathsForProviderAndGroup(String provider, String group); + + /// Gets publishable providers. + /// + /// Laravel-compatible: Provider listing. + List publishableProviders(); + + /// Gets publishable migration paths. + /// + /// Laravel-compatible: Migration path listing. + List publishableMigrationPaths(); + + /// Gets publishable groups. + /// + /// Laravel-compatible: Group listing. + List publishableGroups(); + + /// Registers commands. + /// + /// Laravel-compatible: Command registration. + void commands(List commands); + + /// Gets default providers. + /// + /// Laravel-compatible: Default provider listing. + List defaultProviders(); + + /// Adds provider to bootstrap file. + /// + /// Laravel-compatible: Provider bootstrapping. + bool addProviderToBootstrapFile(String provider, [String? path]); + + /// Registers a singleton. + /// + /// Laravel-compatible: Singleton binding with Dart typing. + void singleton(T instance); + + /// Registers a factory binding. + /// + /// Laravel-compatible: Factory binding with Dart typing. + void bind(T Function(dynamic) factory); + + /// Gets a service. + /// + /// Laravel-compatible: Service resolution with Dart typing. + T make([Type? type]); + + /// Checks if service exists. + /// + /// Laravel-compatible: Binding check with Dart typing. + bool has(); + + /// Registers tagged bindings. + /// + /// Laravel-compatible: Tag binding with Dart typing. + void tag(List abstracts, List tags); + + /// Registers an event listener. + /// + /// Laravel-compatible: Event listener registration. + void listen(String event, Function listener); + + /// Registers middleware. + /// + /// Laravel-compatible: Middleware registration. + void middleware(String name, Function handler); +} + +/// Contract for deferrable providers. +/// +/// Laravel-compatible: Defines providers that can be loaded +/// on demand rather than at application startup. +@sealed +abstract class DeferrableProviderContract { + /// Gets services provided by this provider. + /// + /// Laravel-compatible: Lists deferred services. + List provides(); +} + +/// Contract for provider static functionality. +/// +/// Platform-specific: Provides static helper methods and properties +/// following Laravel's patterns for static configuration. +@sealed +abstract class ServiceProviderStaticContract { + /// Gets publishable migration paths. + static final List publishableMigrationPaths = []; + + /// Gets publishable paths. + static final Map> publishablePaths = {}; + + /// Gets publishable groups. + static final Map> publishableGroups = {}; + + /// Gets publishable provider paths. + static final Map> publishableProviderPaths = {}; +} diff --git a/packages/contracts/lib/src/testing/testing.dart b/packages/contracts/lib/src/testing/testing.dart new file mode 100644 index 0000000..1bb17b1 --- /dev/null +++ b/packages/contracts/lib/src/testing/testing.dart @@ -0,0 +1,2 @@ +/// Testing package contracts +export 'testing_contract.dart'; diff --git a/packages/contracts/lib/src/testing/testing_contract.dart b/packages/contracts/lib/src/testing/testing_contract.dart new file mode 100644 index 0000000..af9cc43 --- /dev/null +++ b/packages/contracts/lib/src/testing/testing_contract.dart @@ -0,0 +1,302 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; +import 'dart:typed_data'; +import 'package:meta/meta.dart'; + +/// Contract for mock HTTP requests. +/// +/// This contract defines how HTTP requests should be mocked +/// for testing purposes. +@sealed +abstract class MockHttpRequestContract + implements HttpRequest, StreamSink>, StringSink { + /// Gets the request method. + @override + String get method; + + /// Gets the request URI. + @override + Uri get uri; + + /// Gets request headers. + @override + HttpHeaders get headers; + + /// Gets request cookies. + @override + List get cookies; + + /// Gets connection info. + @override + HttpConnectionInfo get connectionInfo; + + /// Gets request session. + @override + HttpSession get session; + + /// Gets request content length. + @override + int get contentLength; + + /// Gets protocol version. + @override + String get protocolVersion; + + /// Gets SSL/TLS certificate. + @override + X509Certificate? get certificate; + + /// Gets whether connection is persistent. + @override + bool get persistentConnection; + + /// Gets requested URI. + @override + Uri get requestedUri; + + /// Sets requested URI. + set requestedUri(Uri value); + + /// Gets response object. + @override + HttpResponse get response; +} + +/// Contract for mock HTTP responses. +/// +/// This contract defines how HTTP responses should be mocked +/// for testing purposes. +@sealed +abstract class MockHttpResponseContract + implements HttpResponse, Stream> { + /// Gets/sets status code. + @override + int get statusCode; + @override + set statusCode(int value); + + /// Gets/sets reason phrase. + @override + String get reasonPhrase; + @override + set reasonPhrase(String value); + + /// Gets/sets content length. + @override + int get contentLength; + @override + set contentLength(int value); + + /// Gets/sets deadline. + @override + Duration? get deadline; + @override + set deadline(Duration? value); + + /// Gets/sets encoding. + @override + Encoding get encoding; + @override + set encoding(Encoding value); + + /// Gets/sets persistent connection flag. + @override + bool get persistentConnection; + @override + set persistentConnection(bool value); + + /// Gets/sets buffer output flag. + @override + bool get bufferOutput; + @override + set bufferOutput(bool value); + + /// Gets response headers. + @override + HttpHeaders get headers; + + /// Gets response cookies. + @override + List get cookies; + + /// Gets connection info. + @override + HttpConnectionInfo get connectionInfo; + + /// Gets done future. + @override + Future get done; + + /// Detaches socket. + @override + Future detachSocket({bool writeHeaders = true}); + + /// Redirects to location. + @override + Future redirect(Uri location, {int status = HttpStatus.movedTemporarily}); +} + +/// Contract for mock HTTP sessions. +/// +/// This contract defines how HTTP sessions should be mocked +/// for testing purposes. +@sealed +abstract class MockHttpSessionContract implements HttpSession { + /// Gets session ID. + @override + String get id; + + /// Gets/sets whether session is new. + @override + bool get isNew; + @override + set isNew(bool value); + + /// Gets session data. + Map get data; + + /// Gets session value. + @override + dynamic operator [](Object? key); + + /// Sets session value. + @override + void operator []=(dynamic key, dynamic value); + + /// Removes session value. + @override + dynamic remove(Object? key); + + /// Clears all session data. + @override + void clear(); + + /// Destroys the session. + @override + Future destroy(); +} + +/// Contract for mock HTTP headers. +/// +/// This contract defines how HTTP headers should be mocked +/// for testing purposes. +@sealed +abstract class MockHttpHeadersContract implements HttpHeaders { + /// Gets header value. + @override + String? value(String name); + + /// Adds header value. + @override + void add(String name, Object value, {bool preserveHeaderCase = false}); + + /// Removes header. + @override + void remove(String name, Object value); + + /// Removes all headers. + @override + void removeAll(String name); + + /// Sets header value. + @override + void set(String name, Object value, {bool preserveHeaderCase = false}); + + /// Gets header values. + @override + List? operator [](String name); + + /// Gets all header names. + @override + List get names; + + /// Gets header values. + @override + Iterable? getAll(String name); + + /// Clears all headers. + @override + void clear(); + + /// Gets whether headers are mutable. + @override + bool get mutable; + + /// Gets content type. + @override + ContentType? get contentType; + + /// Sets content type. + @override + set contentType(ContentType? value); + + /// Gets date. + @override + DateTime? get date; + + /// Sets date. + @override + set date(DateTime? value); + + /// Gets expires date. + @override + DateTime? get expires; + + /// Sets expires date. + @override + set expires(DateTime? value); + + /// Gets if-modified-since date. + @override + DateTime? get ifModifiedSince; + + /// Sets if-modified-since date. + @override + set ifModifiedSince(DateTime? value); + + /// Gets host. + @override + String? get host; + + /// Sets host. + @override + set host(String? value); + + /// Gets port. + @override + int? get port; + + /// Sets port. + @override + set port(int? value); + + /// Locks headers from modification. + void lock(); + + /// Gets whether headers are locked. + bool get locked; +} + +/// Contract for mock connection info. +/// +/// This contract defines how connection info should be mocked +/// for testing purposes. +@sealed +abstract class MockConnectionInfoContract implements HttpConnectionInfo { + /// Gets local address. + @override + InternetAddress get localAddress; + + /// Gets local port. + @override + int get localPort; + + /// Gets remote address. + @override + InternetAddress get remoteAddress; + + /// Gets remote port. + @override + int get remotePort; +} diff --git a/packages/contracts/pubspec.yaml b/packages/contracts/pubspec.yaml new file mode 100644 index 0000000..c95ca4b --- /dev/null +++ b/packages/contracts/pubspec.yaml @@ -0,0 +1,13 @@ +name: platform_contracts +description: Core contracts for the Platform framework +version: 1.0.0 + +environment: + sdk: '>=3.0.0 <4.0.0' + +dependencies: + meta: ^1.9.0 + +dev_dependencies: + lints: ^2.0.0 + test: ^1.21.0