@grupodiariodaregiao/bunstone 0.0.27

package/dist/lib/adapters/cache-adapter.d.ts

@@ -0,0 +1,19 @@
+export type CacheValue = Record<string, unknown>;
+export type CacheSetOptions = {
+    permanent: true;
+} | {
+    ttlSeconds: number;
+} | {
+    ttl: number;
+};
+export type CacheAdapterConfig = {
+    url: string;
+};
+export declare class CacheAdapter {
+    private readonly client;
+    constructor(config?: CacheAdapterConfig);
+    set(key: string, value: CacheValue, options?: CacheSetOptions): Promise<void>;
+    get<T extends CacheValue>(key: string): Promise<T>;
+    exists(key: string): Promise<boolean>;
+    remove(key: string): Promise<void>;
+}

package/dist/lib/adapters/form-data.d.ts

@@ -0,0 +1,4 @@
+import { type FormDataOptions } from "../http-params";
+import "reflect-metadata";
+export { type FormDataPayload, type FormDataFields } from "../http-params";
+export declare function FormData(options?: FormDataOptions): ParameterDecorator;

package/dist/lib/adapters/upload-adapter.d.ts

@@ -0,0 +1,22 @@
+import { S3Client, type S3Options } from "bun";
+import "reflect-metadata";
+export type S3UploadBody = Parameters<S3Client["write"]>[1];
+export type MinioConfig = {
+    endpoint: string;
+    accessKey: string;
+    secretKey: string;
+    bucket: string;
+};
+export type S3UploadParams = {
+    path: string;
+    body: S3UploadBody;
+    contentType?: string;
+    acl?: S3Options["acl"];
+};
+export declare class UploadAdatper {
+    private readonly client;
+    constructor(config?: MinioConfig);
+    upload(params: S3UploadParams): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    remove(path: string): Promise<void>;
+}

package/dist/lib/app-startup.d.ts

@@ -0,0 +1,76 @@
+import Elysia from "elysia";
+import "reflect-metadata";
+import type { Options } from "./types/options";
+/**
+ * Main entry point for the Bunstone application.
+ * Handles module registration, route setup, and server startup.
+ */
+export declare class AppStartup {
+    private static elysia;
+    private static readonly logger;
+    private static readonly registeredSagas;
+    private static readonly viewBundles;
+    /**
+     * Initializes the application from a root module.
+     *
+     * @param module The root module of the application.
+     * @param options Optional configuration (e.g., CORS).
+     * @returns An object with a `listen` method to start the server.
+     */
+    static create(module: any, options?: Options): {
+        /**
+         * Starts the server on the specified port.
+         * @param port The port number to listen on.
+         */
+        listen: typeof AppStartup.listen;
+        /**
+         * Returns the underlying Elysia instance.
+         */
+        getElysia: () => Elysia<"", {
+            decorator: {};
+            store: {};
+            derive: {};
+            resolve: {};
+        }, {
+            typebox: {};
+            error: {};
+        }, {
+            schema: {};
+            standaloneSchema: {};
+            macro: {};
+            macroFn: {};
+            parser: {};
+            response: {};
+        }, {}, {
+            derive: {};
+            resolve: {};
+            schema: {};
+            standaloneSchema: {};
+            response: {};
+        }, {
+            derive: {};
+            resolve: {};
+            schema: {};
+            standaloneSchema: {};
+            response: {};
+        }>;
+    };
+    /**
+     * Bundles a client-side component for hydration (internal).
+     */
+    private static bundle;
+    private static autoBundle;
+    /**
+     * Starts the server on the specified port.
+     * @param port The port number to listen on.
+     */
+    static listen(port: number): void;
+    private static executeControllerMethod;
+    private static registerModules;
+    private static registerRoutes;
+    private static registerTimeouts;
+    private static registerCronJobs;
+    private static registerCqrsHandlers;
+    private static startWithJWT;
+    private static getControllerHandler;
+}

package/dist/lib/components/layout.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface LayoutProps {
+    title?: string;
+    children: React.ReactNode;
+    data?: any;
+    bundle?: string;
+}
+export declare const Layout: React.FC<LayoutProps>;

package/dist/lib/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const PARAM_METADATA_KEY: unique symbol;

package/dist/lib/controller.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+/**
+ * Decorator that marks a class as an HTTP controller.
+ * Controllers are responsible for handling incoming requests and returning responses.
+ *
+ * @param pathname The base path for all routes defined within this controller. Defaults to "/".
+ *
+ * @example
+ * ```typescript
+ * @Controller('users')
+ * export class UserController {}
+ * ```
+ */
+export declare function Controller(pathname?: string): any;

package/dist/lib/cqrs/command-bus.d.ts

@@ -0,0 +1,19 @@
+import type { ICommand, ICommandHandler } from "./interfaces/command.interface";
+/**
+ * Bus for dispatching commands to their respective handlers.
+ */
+export declare class CommandBus {
+    private handlers;
+    /**
+     * Registers a list of command handlers.
+     * @param handlers Array of command handler instances.
+     */
+    register(handlers: ICommandHandler[]): void;
+    /**
+     * Executes a command and returns the result.
+     * @param command The command instance to execute.
+     * @returns The result of the command execution.
+     * @throws Error if no handler is found for the command.
+     */
+    execute<T extends ICommand, R = any>(command: T): Promise<R>;
+}

package/dist/lib/cqrs/cqrs-module.d.ts

@@ -0,0 +1,2 @@
+export declare class CqrsModule {
+}

package/dist/lib/cqrs/decorators/command-handler.decorator.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export declare const COMMAND_HANDLER_METADATA = "dip:cqrs:command-handler";
+/**
+ * Decorator that marks a class as a command handler.
+ * @param command The command class that this handler handles.
+ */
+export declare const CommandHandler: (command: any) => any;

package/dist/lib/cqrs/decorators/event-handler.decorator.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export declare const EVENT_HANDLER_METADATA = "dip:cqrs:event-handler";
+/**
+ * Decorator that marks a class as an event handler.
+ * @param events The event classes that this handler handles.
+ */
+export declare const EventsHandler: (...events: any[]) => any;

package/dist/lib/cqrs/decorators/query-handler.decorator.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export declare const QUERY_HANDLER_METADATA = "dip:cqrs:query-handler";
+/**
+ * Decorator that marks a class as a query handler.
+ * @param query The query class that this handler handles.
+ */
+export declare const QueryHandler: (query: any) => any;

package/dist/lib/cqrs/decorators/saga.decorator.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export declare const SAGA_METADATA = "dip:cqrs:saga";
+/**
+ * Decorator that marks a property as a Saga.
+ * Sagas are reactive event streams that can dispatch commands or other events.
+ */
+export declare const Saga: () => any;

package/dist/lib/cqrs/event-bus.d.ts

@@ -0,0 +1,38 @@
+import type { IEvent, IEventHandler } from "./interfaces/event.interface";
+export type IEventStream = {
+    pipe: (...operators: any[]) => IEventStream;
+    subscribe: (callback: (event: IEvent) => void) => void;
+};
+/**
+ * Bus for publishing and subscribing to events.
+ * Supports event handlers and reactive streams (Sagas).
+ */
+export declare class EventBus {
+    private handlers;
+    private listeners;
+    /**
+     * Registers a list of event handlers.
+     * @param handlers Array of event handler instances.
+     */
+    register(handlers: IEventHandler[]): void;
+    /**
+     * Publishes an event to all registered handlers and listeners.
+     * @param event The event instance to publish.
+     */
+    publish<T extends IEvent>(event: T): void;
+    /**
+     * Returns a stream of events for reactive processing.
+     * Used primarily by Sagas.
+     */
+    get stream(): IEventStream;
+}
+/**
+ * Filters events by type in a Saga stream.
+ * @param types The event classes to filter by.
+ */
+export declare const ofType: (...types: any[]) => (event: IEvent, next: (event: IEvent) => void) => void;
+/**
+ * Transforms events in a Saga stream.
+ * @param fn The transformation function.
+ */
+export declare const map: (fn: (event: any) => any) => (event: IEvent, next: (result: any) => void) => void;

package/dist/lib/cqrs/interfaces/command.interface.d.ts

@@ -0,0 +1,5 @@
+export interface ICommand {
+}
+export interface ICommandHandler<T extends ICommand = any, R = any> {
+    execute(command: T): Promise<R>;
+}

package/dist/lib/cqrs/interfaces/event.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IEvent {
+}
+export interface IEventHandler<T extends IEvent = any> {
+    handle(event: T): any;
+}

package/dist/lib/cqrs/interfaces/query.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IQuery {
+}
+export interface IQueryHandler<T extends IQuery = any, R = any> {
+    execute(query: T): Promise<R>;
+}

package/dist/lib/cqrs/query-bus.d.ts

@@ -0,0 +1,19 @@
+import type { IQuery, IQueryHandler } from "./interfaces/query.interface";
+/**
+ * Bus for dispatching queries to their respective handlers.
+ */
+export declare class QueryBus {
+    private handlers;
+    /**
+     * Registers a list of query handlers.
+     * @param handlers Array of query handler instances.
+     */
+    register(handlers: IQueryHandler[]): void;
+    /**
+     * Executes a query and returns the result.
+     * @param query The query instance to execute.
+     * @returns The result of the query execution.
+     * @throws Error if no handler is found for the query.
+     */
+    execute<T extends IQuery, R = any>(query: T): Promise<R>;
+}

package/dist/lib/database/sql-module.d.ts

@@ -0,0 +1,25 @@
+import { SQL } from "bun";
+type ConnectionOptions = {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    database: string;
+    provider: "postgresql" | "mysql" | "sqlite";
+};
+export declare class SqlService {
+    query<T = any>(query: string, params?: any[]): Promise<T[]>;
+    transaction(queries: Array<{
+        query: string;
+        params?: any[];
+    }>): Promise<void>;
+    bulkInsert<T = any>(table: string, values: T[]): Promise<void>;
+    private getSqlInstance;
+}
+export declare class SqlModule {
+    private static sqlInstance;
+    static register(connection: ConnectionOptions): typeof SqlModule;
+    static register(connection: string): typeof SqlModule;
+    static getSqlInstance(): SQL;
+}
+export {};

package/dist/lib/guard.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import type { ClassConstructor } from "./interfaces/class-constructor";
+/**
+ * Decorator to define a guard class.
+ * @param guard The guard class constructor.
+ * @returns A class or method decorator.
+ */
+export declare function Guard(guard: ClassConstructor): any;

package/dist/lib/http-exceptions.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Base class for all HTTP exceptions.
+ */
+export declare class HttpException extends Error {
+    readonly response: string | object;
+    readonly status: number;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+}
+/**
+ * 400 Bad Request Exception
+ */
+export declare class BadRequestException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 401 Unauthorized Exception
+ */
+export declare class UnauthorizedException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 403 Forbidden Exception
+ */
+export declare class ForbiddenException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 404 Not Found Exception
+ */
+export declare class NotFoundException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 409 Conflict Exception
+ */
+export declare class ConflictException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 422 Unprocessable Entity Exception
+ */
+export declare class UnprocessableEntityException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 500 Internal Server Error Exception
+ */
+export declare class InternalServerErrorException extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * Success "Exceptions" (can be thrown to exit early with a specific status)
+ */
+/**
+ * 200 OK
+ */
+export declare class OkResponse extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 201 Created
+ */
+export declare class CreatedResponse extends HttpException {
+    constructor(response?: string | object);
+}
+/**
+ * 204 No Content
+ */
+export declare class NoContentResponse extends HttpException {
+    constructor();
+}

package/dist/lib/http-methods.d.ts

@@ -0,0 +1,36 @@
+import "reflect-metadata";
+/**
+ * Route decorator for GET requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Get(pathname?: string): any;
+/**
+ * Route decorator for POST requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Post(pathname?: string): any;
+/**
+ * Route decorator for PUT requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Put(pathname?: string): any;
+/**
+ * Route decorator for DELETE requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Delete(pathname?: string): any;
+/**
+ * Route decorator for PATCH requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Patch(pathname?: string): any;
+/**
+ * Route decorator for OPTIONS requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Options(pathname?: string): any;
+/**
+ * Route decorator for HEAD requests.
+ * @param pathname Optional path for the route.
+ */
+export declare function Head(pathname?: string): any;

package/dist/lib/http-params.d.ts

@@ -0,0 +1,28 @@
+import "reflect-metadata";
+import { type ZodType } from "zod/v4";
+export declare enum ParamType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADER = "header",
+    REQUEST = "request",
+    FORM_DATA = "form-data"
+}
+export declare function Body(schema?: ZodType): any;
+export declare function Param(schema?: ZodType): any;
+export declare function Param(key?: string): any;
+export declare function Query(schema?: ZodType): any;
+export declare function Query(key?: string): any;
+export declare function Header(key: string): any;
+export declare function Request(): any;
+export declare function processParameters(request: any, target: any, propertyKey: string): Promise<any[]>;
+export type FormDataOptions = {
+    fileField?: string;
+    allowedTypes?: string[];
+    jsonField?: string;
+};
+export type FormDataFields = Record<string, string | string[]>;
+export type FormDataPayload = {
+    files: File[];
+    json?: unknown;
+};

package/dist/lib/injectable.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+/**
+ * Decorator that marks a class as available to be injected as a dependency.
+ * Classes decorated with `@Injectable()` can be managed by the Bunstone DI container.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class UserService {}
+ * ```
+ */
+export declare function Injectable(): any;

package/dist/lib/interfaces/class-constructor.d.ts

@@ -0,0 +1,6 @@
+/** Interface representing a class constructor.
+ * @property new (...args: any[]): any - A constructor that can take any number of arguments and returns any type.
+ */
+export interface ClassConstructor {
+    new (...args: any[]): any;
+}

package/dist/lib/interfaces/guard-contract.d.ts

@@ -0,0 +1,7 @@
+import type { HttpRequest } from "../types/http-request";
+/** Interface for a guard contract that validates HTTP requests.
+ * @property validate(req: HttpRequest): boolean | Promise<boolean> - Method to validate an HTTP request, returning a boolean or a Promise that resolves to a boolean.
+ */
+export interface GuardContract {
+    validate(req: HttpRequest): boolean | Promise<boolean>;
+}

package/dist/lib/jwt/jwt-module.d.ts

@@ -0,0 +1,13 @@
+import type { JWTOption } from "@elysiajs/jwt";
+import "reflect-metadata";
+/**
+ * Module for configuring JWT authentication.
+ */
+export declare class JwtModule {
+    private static options;
+    /**
+     * Configures the JWT options for the application.
+     * @param options JWT configuration options (secret, algorithm, expiration, etc.).
+     */
+    static register(options: JWTOption): typeof JwtModule;
+}

package/dist/lib/jwt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Decorator that enables JWT protection for a controller or a specific method.
+ * Requires the JwtModule to be configured in the root module.
+ */
+export declare function Jwt(): any;

package/dist/lib/module.d.ts

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+import type { ModuleConfig } from "./types/module-config";
+/**
+ * Decorator that marks a class as a module.
+ * Modules are used to organize the application structure and manage dependency injection scopes.
+ *
+ * @param moduleConfig Configuration object defining controllers, providers, imports, and exports.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   controllers: [AppController],
+ *   providers: [AppService],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare function Module(moduleConfig?: ModuleConfig): any;

package/dist/lib/openapi.d.ts

@@ -0,0 +1,52 @@
+import "reflect-metadata";
+export declare const API_TAGS_METADATA = "dip:openapi:tags";
+export declare const API_OPERATION_METADATA = "dip:openapi:operation";
+export declare const API_RESPONSE_METADATA = "dip:openapi:responses";
+export declare const API_HEADERS_METADATA = "dip:openapi:headers";
+/**
+ * Decorator that adds tags to a controller or method for OpenAPI.
+ * @param tags List of tags.
+ */
+export declare function ApiTags(...tags: string[]): any;
+/**
+ * Decorator that defines an operation summary and description for OpenAPI.
+ * @param options Operation options.
+ * @param options.summary A short summary of what the operation does.
+ * @param options.description A verbose explanation of the operation behavior.
+ */
+export declare function ApiOperation(options: {
+    summary?: string;
+    description?: string;
+}): any;
+/**
+ * Decorator that defines a response for OpenAPI.
+ * @param options Response options.
+ * @param options.status The HTTP status code.
+ * @param options.description A short description of the response.
+ * @param options.type Optional Zod schema or type for the response body.
+ */
+export declare function ApiResponse(options: {
+    status: number;
+    description: string;
+    type?: any;
+}): any;
+/**
+ * Decorator that defines a header for OpenAPI.
+ * @param options Header options.
+ */
+export declare function ApiHeader(options: {
+    name: string;
+    description?: string;
+    required?: boolean;
+    schema?: any;
+}): any;
+/**
+ * Decorator that defines multiple headers for OpenAPI.
+ * @param headers List of header options.
+ */
+export declare function ApiHeaders(headers: {
+    name: string;
+    description?: string;
+    required?: boolean;
+    schema?: any;
+}[]): (target: any, propertyKey?: string | symbol) => void;

package/dist/lib/render.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export declare const RENDER_METADATA = "dip:render:component";
+/**
+ * Decorator to specify a React component to render the controller's response.
+ * @param component The React component to use as a View.
+ */
+export declare function Render(component: any): any;

package/dist/lib/schedule/cron/cron.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+/**
+ * Decorator to define a cron expression.
+ * @param expression The cron expression string.
+ * @returns A method decorator.
+ */
+export declare function Cron(expression: string): any;

package/dist/lib/schedule/cron/mappers/map-providers-with-cron.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleConfig } from "../../../types/module-config";
+export declare class MapProvidersWithCron {
+    static execute(providers?: ModuleConfig["providers"]): Map<any, {
+        expression?: string;
+        delay?: number;
+        methodName: string;
+    }[]>;
+}

package/dist/lib/schedule/timeout/mappers/map-providers-with-timeouts.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import type { ModuleConfig } from "../../../types/module-config";
+export declare class MapProvidersWithTimeout {
+    static execute(providers?: ModuleConfig["providers"]): Map<any, {
+        expression?: string;
+        delay?: number;
+        methodName: string;
+    }[]>;
+}

package/dist/lib/schedule/timeout/timeout.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+/**
+ * Decorator to define a timeout delay.
+ * @param delay The delay in milliseconds.
+ * @returns A method decorator.
+ */
+export declare function Timeout(delay: number): any;

package/dist/lib/types/http-request.d.ts

@@ -0,0 +1,13 @@
+import type { HTTPHeaders, RouteSchema } from "elysia";
+/**
+ * Represents an HTTP request with headers and optional JWT methods.
+ * @property headers - The HTTP headers of the request.
+ * @property jwt - Optional JWT methods for signing and verifying tokens.
+ */
+export type HttpRequest = RouteSchema & {
+    headers: HTTPHeaders;
+    jwt?: {
+        sign(payload: Record<string, any>): Promise<string>;
+        verify(token?: string): Promise<false | Record<string, any>>;
+    };
+};