@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/ConsoleKernel-CqCVrdZs.d.ts

@@ -0,0 +1,207 @@
+import { C as Container } from './Application-DtWDHXr1.js';
+
+/**
+ * Parsed argument definition.
+ */
+interface ArgumentDefinition {
+    name: string;
+    description?: string;
+    required: boolean;
+    array: boolean;
+    defaultValue?: string;
+}
+/**
+ * Parsed option definition.
+ */
+interface OptionDefinition {
+    name: string;
+    shortcut?: string;
+    description?: string;
+    requiresValue: boolean;
+    defaultValue?: string | boolean;
+    array: boolean;
+}
+/**
+ * Parsed signature.
+ */
+interface ParsedSignature {
+    name: string;
+    arguments: ArgumentDefinition[];
+    options: OptionDefinition[];
+}
+/**
+ * Command class type.
+ */
+interface CommandClass {
+    signature: string;
+    description: string;
+    new (container?: Container): CommandInstance;
+}
+/**
+ * Command instance type.
+ */
+interface CommandInstance {
+    setInput(argv: string[]): void;
+    setOutput(output: OutputInterface): void;
+    setKernel(kernel: {
+        handle(argv: string[]): Promise<number>;
+    }): void;
+    run(): Promise<number>;
+}
+/**
+ * Output interface.
+ */
+interface OutputInterface {
+    info(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    success(message: string): void;
+    line(message: string): void;
+    newLine(count?: number): void;
+    table(headers: string[], rows: string[][]): void;
+    write(message: string): void;
+}
+/**
+ * Input interface.
+ */
+interface InputInterface {
+    argument<T = string>(name: string): T;
+    arguments(): Record<string, string | string[]>;
+    option<T = string | boolean>(name: string): T | undefined;
+    options(): Record<string, string | boolean | string[]>;
+    hasOption(name: string): boolean;
+}
+/**
+ * Console kernel options.
+ */
+interface ConsoleKernelOptions {
+    container?: Container;
+}
+/**
+ * Schedule definition for a command.
+ */
+interface ScheduledCommand {
+    command: string;
+    args?: string[];
+    expression: string;
+    timezone?: string;
+    description?: string;
+}
+/**
+ * Interactive prompt types.
+ */
+interface PromptInterface {
+    ask(question: string, defaultValue?: string): Promise<string>;
+    confirm(question: string, defaultValue?: boolean): Promise<boolean>;
+    choice<T extends string>(question: string, choices: T[], defaultValue?: T): Promise<T>;
+    secret(question: string): Promise<string>;
+}
+/**
+ * Progress bar interface.
+ */
+interface ProgressInterface {
+    start(total: number): void;
+    advance(step?: number): void;
+    finish(): void;
+    setProgress(current: number): void;
+}
+
+/**
+ * Console kernel for managing and executing commands.
+ *
+ * @example
+ * ```typescript
+ * const kernel = new ConsoleKernel()
+ *
+ * kernel.register(CreateUserCommand)
+ * kernel.register(SendNotificationsCommand)
+ *
+ * // Execute command
+ * const exitCode = await kernel.handle(['users:create', 'john@example.com', '--admin'])
+ * ```
+ */
+declare class ConsoleKernel {
+    /**
+     * Registered commands.
+     */
+    protected commands: Map<string, CommandClass>;
+    /**
+     * Service container.
+     */
+    protected container?: Container;
+    /**
+     * Output instance.
+     */
+    protected output: OutputInterface;
+    constructor(options?: ConsoleKernelOptions);
+    /**
+     * Register a command.
+     */
+    register(command: CommandClass): this;
+    /**
+     * Register multiple commands.
+     */
+    registerMany(commands: CommandClass[]): this;
+    /**
+     * Get all registered commands.
+     */
+    getCommands(): Map<string, CommandClass>;
+    /**
+     * Get a command by name.
+     */
+    getCommand(name: string): CommandClass | undefined;
+    /**
+     * Check if a command is registered.
+     */
+    hasCommand(name: string): boolean;
+    /**
+     * Set the output instance.
+     */
+    setOutput(output: OutputInterface): this;
+    /**
+     * Get the output instance.
+     */
+    getOutput(): OutputInterface;
+    /**
+     * Handle command execution.
+     */
+    handle(argv?: string[]): Promise<number>;
+    /**
+     * Run a command.
+     */
+    protected runCommand(CommandClass: CommandClass, args: string[]): Promise<number>;
+    /**
+     * Show help.
+     */
+    protected showHelp(): void;
+    /**
+     * Show help for a specific command.
+     */
+    protected showCommandHelp(commandName: string): void;
+    /**
+     * List all commands.
+     */
+    protected listCommands(): void;
+    /**
+     * Group commands by namespace.
+     */
+    protected groupCommands(): Map<string, Map<string, CommandClass>>;
+    /**
+     * Suggest similar commands.
+     */
+    protected suggestCommands(input: string): void;
+    /**
+     * Calculate string similarity (simple Dice coefficient).
+     */
+    protected similarity(a: string, b: string): number;
+    /**
+     * Call a command programmatically.
+     */
+    call(commandName: string, args?: string[], silent?: boolean): Promise<number>;
+}
+/**
+ * Create a console kernel.
+ */
+declare function createConsoleKernel(options?: ConsoleKernelOptions): ConsoleKernel;
+
+export { type ArgumentDefinition as A, ConsoleKernel as C, type InputInterface as I, type OptionDefinition as O, type ParsedSignature as P, type ScheduledCommand as S, type CommandInstance as a, type OutputInterface as b, type CommandClass as c, type ConsoleKernelOptions as d, type ProgressInterface as e, type PromptInterface as f, createConsoleKernel as g };

package/dist/EventManager-CmIoLt7r.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Base class for all application events.
+ *
+ * @example
+ * ```ts
+ * class UserRegistered extends Event {
+ *   constructor(
+ *     public readonly userId: string,
+ *     public readonly email: string
+ *   ) {
+ *     super()
+ *   }
+ * }
+ *
+ * // Emit the event
+ * await events.emit(new UserRegistered('123', 'user@example.com'))
+ * ```
+ */
+declare abstract class Event {
+    /**
+     * Timestamp when the event was created.
+     */
+    readonly timestamp: Date;
+    /**
+     * Get the event name (class name by default).
+     * Override this to customize the event name.
+     */
+    static get eventName(): string;
+    /**
+     * Get the event name from an instance.
+     */
+    get eventName(): string;
+}
+
+/**
+ * Event class constructor type.
+ */
+interface EventClass<T extends Event = Event> {
+    new (...args: any[]): T;
+    eventName: string;
+}
+/**
+ * Event listener function type.
+ */
+type EventListener<T extends Event = Event> = (event: T) => void | Promise<void>;
+/**
+ * Options for registering an event listener.
+ */
+interface ListenerOptions {
+    /**
+     * If true, the listener will be removed after the first invocation.
+     * @default false
+     */
+    once?: boolean;
+    /**
+     * Priority of the listener. Higher values are executed first.
+     * @default 0
+     */
+    priority?: number;
+    /**
+     * If specified, the listener will be dispatched to a queue instead of being executed immediately.
+     * Requires the Queue system to be configured.
+     */
+    queue?: string;
+}
+/**
+ * Internal representation of a registered listener.
+ */
+interface RegisteredListener<T extends Event = Event> {
+    listener: EventListener<T>;
+    options: ListenerOptions;
+}
+/**
+ * Event subscription handle for unsubscribing.
+ */
+interface EventSubscription {
+    /**
+     * Unsubscribe the listener.
+     */
+    unsubscribe(): void;
+}
+
+/**
+ * Event manager for registering listeners and emitting events.
+ *
+ * @example
+ * ```ts
+ * const events = new EventManager()
+ *
+ * // Register a listener
+ * events.on(UserRegistered, async (event) => {
+ *   console.log(`User ${event.userId} registered`)
+ *   await sendWelcomeEmail(event.email)
+ * })
+ *
+ * // Register a one-time listener
+ * events.once(AppStarted, () => {
+ *   console.log('App started!')
+ * })
+ *
+ * // Emit an event
+ * await events.emit(new UserRegistered('123', 'user@example.com'))
+ * ```
+ */
+declare class EventManager {
+    private readonly listeners;
+    /**
+     * Queue dispatcher function (set when Queue system is integrated).
+     */
+    private queueDispatcher?;
+    /**
+     * Register a listener for an event.
+     *
+     * @param event - Event class to listen for
+     * @param listener - Listener function
+     * @param options - Listener options
+     * @returns Subscription handle for unsubscribing
+     *
+     * @example
+     * ```ts
+     * // Basic usage
+     * events.on(UserRegistered, (e) => console.log(e.email))
+     *
+     * // With options
+     * events.on(UserRegistered, (e) => sendEmail(e), { priority: 10 })
+     *
+     * // Unsubscribe later
+     * const sub = events.on(UserRegistered, handler)
+     * sub.unsubscribe()
+     * ```
+     */
+    on<T extends Event>(event: EventClass<T> | string, listener: EventListener<T>, options?: ListenerOptions): EventSubscription;
+    /**
+     * Register a one-time listener for an event.
+     * The listener will be automatically removed after the first invocation.
+     *
+     * @param event - Event class to listen for
+     * @param listener - Listener function
+     * @param options - Additional listener options (once is always true)
+     * @returns Subscription handle for unsubscribing
+     */
+    once<T extends Event>(event: EventClass<T> | string, listener: EventListener<T>, options?: Omit<ListenerOptions, 'once'>): EventSubscription;
+    /**
+     * Remove a listener for an event.
+     *
+     * @param event - Event class
+     * @param listener - Listener to remove (if omitted, all listeners for the event are removed)
+     */
+    off<T extends Event>(event: EventClass<T> | string, listener?: EventListener<T>): void;
+    /**
+     * Emit an event to all registered listeners.
+     * Listeners are executed in order of priority (highest first).
+     * Async listeners are awaited sequentially.
+     *
+     * @param event - Event instance to emit
+     *
+     * @example
+     * ```ts
+     * await events.emit(new UserRegistered('123', 'user@example.com'))
+     * ```
+     */
+    emit<T extends Event>(event: T): Promise<void>;
+    /**
+     * Emit an event to all registered listeners in parallel.
+     * Use this when listener execution order doesn't matter and you want faster execution.
+     *
+     * @param event - Event instance to emit
+     */
+    emitParallel<T extends Event>(event: T): Promise<void>;
+    /**
+     * Check if an event has any listeners registered.
+     *
+     * @param event - Event class or event name
+     */
+    hasListeners(event: EventClass | string): boolean;
+    /**
+     * Get all listeners for an event.
+     *
+     * @param event - Event class or event name
+     */
+    getListeners<T extends Event>(event: EventClass<T> | string): EventListener<T>[];
+    /**
+     * Get the count of listeners for an event.
+     *
+     * @param event - Event class or event name
+     */
+    listenerCount(event: EventClass | string): number;
+    /**
+     * Get all registered event names.
+     */
+    eventNames(): string[];
+    /**
+     * Remove all listeners for all events.
+     */
+    removeAllListeners(): void;
+    /**
+     * Set the queue dispatcher function.
+     * This is called by the Queue system when it's integrated.
+     */
+    setQueueDispatcher(dispatcher: (queueName: string, eventName: string, event: Event) => Promise<void>): void;
+}
+/**
+ * Create a new EventManager instance.
+ */
+declare function createEventManager(): EventManager;
+
+export { EventManager as E, type ListenerOptions as L, type RegisteredListener as R, Event as a, type EventClass as b, type EventListener as c, type EventSubscription as d, createEventManager as e };

package/dist/Gate-CNkBYf8m.d.ts

@@ -0,0 +1,268 @@
+import { Context } from 'hono';
+
+/**
+ * User type for authorization.
+ */
+interface AuthUser {
+    id: string | number;
+}
+/**
+ * Gate callback function.
+ */
+type GateCallback<Args extends unknown[] = unknown[]> = {
+    bivarianceHack(user: AuthUser | null, ...args: Args): boolean | Promise<boolean>;
+}['bivarianceHack'];
+/**
+ * Gate before callbacks can short-circuit authorization.
+ * Return true to allow, false to deny, or undefined to continue.
+ */
+type GateBeforeCallback<Args extends unknown[] = unknown[]> = {
+    bivarianceHack(user: AuthUser | null, ability: string, ...args: Args): boolean | undefined | Promise<boolean | undefined>;
+}['bivarianceHack'];
+/**
+ * Gate definition with optional callback.
+ */
+interface GateDefinition {
+    callback: GateCallback;
+}
+/**
+ * Policy method type.
+ */
+type PolicyMethod<T = unknown> = (user: AuthUser | null, model?: T, ...args: unknown[]) => boolean | Promise<boolean>;
+/**
+ * Policy class interface.
+ */
+interface Policy {
+    /**
+     * Run before all other authorization checks.
+     * Return true to allow, false to deny, undefined to continue to specific check.
+     */
+    before?(user: AuthUser | null, ability: string): boolean | undefined | Promise<boolean | undefined>;
+}
+/**
+ * Policy class constructor.
+ */
+interface PolicyClass {
+    new (): Policy;
+}
+/**
+ * Authorization response.
+ */
+interface AuthorizationResponse {
+    allowed: boolean;
+    message?: string;
+    code?: string;
+}
+/**
+ * Gate options.
+ */
+interface GateOptions {
+    /**
+     * Default user resolver from context.
+     */
+    userResolver?: (ctx: Context) => AuthUser | null | Promise<AuthUser | null>;
+}
+/**
+ * Authorization check options.
+ */
+interface AuthorizeOptions {
+    /**
+     * Custom message for denial.
+     */
+    message?: string;
+    /**
+     * HTTP status code for denial.
+     */
+    status?: number;
+}
+/**
+ * Policy registration.
+ */
+interface PolicyRegistration {
+    modelClass: unknown;
+    policyClass: PolicyClass;
+}
+/**
+ * Resource actions for policies.
+ */
+type ResourceAction = 'viewAny' | 'view' | 'create' | 'update' | 'delete' | 'restore' | 'forceDelete';
+/**
+ * Response builder for authorization.
+ */
+interface ResponseBuilder {
+    allow(message?: string): AuthorizationResponse;
+    deny(message?: string, code?: string): AuthorizationResponse;
+    denyWithStatus(status: number, message?: string): AuthorizationResponse & {
+        status: number;
+    };
+    denyAsNotFound(message?: string): AuthorizationResponse & {
+        status: 404;
+    };
+}
+
+/**
+ * Response builder for authorization checks.
+ */
+declare const Response: ResponseBuilder;
+/**
+ * Authorization gate for defining and checking abilities.
+ *
+ * @example
+ * ```typescript
+ * const gate = new Gate()
+ *
+ * // Define abilities
+ * gate.define('edit-post', (user, post) => user.id === post.authorId)
+ * gate.define('admin', (user) => user.role === 'admin')
+ *
+ * // Check abilities
+ * if (await gate.allows('edit-post', post)) {
+ *   // User can edit
+ * }
+ *
+ * // Or throw on denial
+ * await gate.authorize('edit-post', post) // throws if not allowed
+ * ```
+ */
+declare class Gate {
+    /**
+     * Defined gates.
+     */
+    protected gates: Map<string, GateDefinition>;
+    /**
+     * Registered policies.
+     */
+    protected policies: Map<unknown, PolicyClass>;
+    /**
+     * Policy instances cache.
+     */
+    protected policyInstances: Map<PolicyClass, Policy>;
+    /**
+     * Before callbacks.
+     */
+    protected beforeCallbacks: GateBeforeCallback[];
+    /**
+     * After callbacks.
+     */
+    protected afterCallbacks: Array<(user: AuthUser | null, ability: string, result: boolean, args: unknown[]) => void | Promise<void>>;
+    /**
+     * User resolver function.
+     */
+    protected userResolver?: (ctx: Context) => AuthUser | null | Promise<AuthUser | null>;
+    /**
+     * Current user for checks.
+     */
+    protected currentUser: AuthUser | null;
+    constructor(options?: GateOptions);
+    /**
+     * Define a new gate.
+     */
+    define<Args extends unknown[]>(ability: string, callback: GateCallback<Args>): this;
+    /**
+     * Register a policy for a model class.
+     */
+    policy(modelClass: unknown, policyClass: PolicyClass): this;
+    /**
+     * Register a before callback.
+     * Return true to allow, false to deny, undefined to continue.
+     */
+    before<Args extends unknown[]>(callback: GateBeforeCallback<Args>): this;
+    /**
+     * Register an after callback.
+     */
+    after(callback: (user: AuthUser | null, ability: string, result: boolean, args: unknown[]) => void | Promise<void>): this;
+    /**
+     * Set the current user for authorization checks.
+     */
+    forUser(user: AuthUser | null): this;
+    /**
+     * Resolve the user from context.
+     */
+    resolveUser(ctx: Context): Promise<AuthUser | null>;
+    /**
+     * Check if the user has the given ability.
+     */
+    allows(ability: string, ...args: unknown[]): Promise<boolean>;
+    /**
+     * Check if the user doesn't have the given ability.
+     */
+    denies(ability: string, ...args: unknown[]): Promise<boolean>;
+    /**
+     * Check if the user has any of the given abilities.
+     */
+    any(abilities: string[], ...args: unknown[]): Promise<boolean>;
+    /**
+     * Check if the user has all of the given abilities.
+     */
+    all(abilities: string[], ...args: unknown[]): Promise<boolean>;
+    /**
+     * Check if the user has none of the given abilities.
+     */
+    none(abilities: string[], ...args: unknown[]): Promise<boolean>;
+    /**
+     * Authorize the ability or throw an exception.
+     */
+    authorize(ability: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Get the authorization response.
+     */
+    inspect(ability: string, ...args: unknown[]): Promise<AuthorizationResponse>;
+    /**
+     * Check the ability with a specific user.
+     */
+    check(ability: string, user: AuthUser | null, ...args: unknown[]): Promise<boolean>;
+    /**
+     * Check a policy for the given ability.
+     */
+    protected checkPolicy(ability: string, user: AuthUser | null, model: unknown, additionalArgs: unknown[]): Promise<boolean | undefined>;
+    /**
+     * Get or create a policy instance.
+     */
+    protected getPolicyInstance(policyClass: PolicyClass): Policy;
+    /**
+     * Run after callbacks.
+     */
+    protected runAfterCallbacks(user: AuthUser | null, ability: string, result: boolean, args: unknown[]): Promise<void>;
+    /**
+     * Get all defined abilities.
+     */
+    abilities(): string[];
+    /**
+     * Check if an ability is defined.
+     */
+    has(ability: string): boolean;
+    /**
+     * Get the policy for a model.
+     */
+    getPolicyFor(model: unknown): Policy | undefined;
+}
+/**
+ * Create a new gate instance.
+ */
+declare function createGate(options?: GateOptions): Gate;
+/**
+ * Set the global gate instance.
+ */
+declare function setGate(gate: Gate): void;
+/**
+ * Get the global gate instance.
+ */
+declare function getGate(): Gate;
+/**
+ * Define a gate on the global instance.
+ */
+declare function defineGate(ability: string, callback: GateCallback): void;
+/**
+ * Check if the current user can perform an ability.
+ */
+declare function can(ability: string, ...args: unknown[]): Promise<boolean>;
+/**
+ * Check if the current user cannot perform an ability.
+ */
+declare function cannot(ability: string, ...args: unknown[]): Promise<boolean>;
+/**
+ * Authorize or throw.
+ */
+declare function authorize(ability: string, ...args: unknown[]): Promise<void>;
+
+export { type AuthUser as A, Gate as G, type PolicyClass as P, Response as R, type AuthorizationResponse as a, type AuthorizeOptions as b, type GateCallback as c, type GateDefinition as d, type GateOptions as e, type Policy as f, type PolicyMethod as g, type PolicyRegistration as h, type ResourceAction as i, type ResponseBuilder as j, authorize as k, can as l, cannot as m, createGate as n, defineGate as o, getGate as p, setGate as s };