@razvan11/paladin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Razvan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# backend_framwork
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/EnvValidator.d.ts

@@ -0,0 +1,11 @@
+declare enum Env {
+    production = 0,
+    testing = 1,
+    staging = 2,
+    development = 3
+}
+export declare class EnvValidator {
+    readonly env: Env;
+    readonly DB_URL: string;
+}
+export {};

package/dist/app/app.d.ts

@@ -0,0 +1,45 @@
+import 'reflect-metadata';
+import type { Server } from 'bun';
+import { Hono } from 'hono';
+import '../container/container';
+type ControllerClass = new (...args: any[]) => any;
+export interface StaticOptions {
+    /** URL path prefix (e.g., '/static') */
+    path?: string;
+    /** Root directory for static files */
+    root?: string;
+}
+export declare class App {
+    private app;
+    name: string;
+    private container;
+    private validators?;
+    private cors;
+    private logger;
+    constructor(name: string, cors?: string[]);
+    init(): void;
+    /**
+     * Serve static files from a directory
+     * @param options - Static serving options
+     */
+    serveStatic(options?: StaticOptions): this;
+    /**
+     * Register a controller with the app
+     * Reads route metadata and binds handlers to Hono
+     */
+    registerController(ControllerClass: ControllerClass): this;
+    /**
+     * Register multiple controllers at once
+     */
+    registerControllers(...controllers: ControllerClass[]): this;
+    /**
+     * Normalize and combine path segments
+     */
+    private normalizePath;
+    /**
+     * Get the underlying Hono instance for advanced usage
+     */
+    getAppInstance(): Hono;
+    run(): Promise<Server<unknown> | null>;
+}
+export {};

package/dist/components/LayoutView.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LayoutView Component
+ * A base HTML layout for server-side rendering React apps
+ */
+import type { FC, ReactNode } from 'react';
+export interface LayoutViewProps {
+    /** Page title */
+    title: string;
+    /** Meta description for SEO */
+    description?: string;
+    /** Array of CSS stylesheet URLs */
+    styles?: string[];
+    /** Array of JavaScript file URLs */
+    scripts?: string[];
+    /** Additional class names for the body */
+    className?: string;
+    /** Page content / children */
+    children?: ReactNode;
+    /** Additional head content (meta tags, etc.) */
+    head?: ReactNode;
+    /** Inline data to pass to the client */
+    clientData?: Record<string, unknown>;
+}
+export declare const LayoutView: FC<LayoutViewProps>;
+/**
+ * PageLoader Component
+ * A simple loading indicator shown while the React app hydrates
+ */
+export declare const PageLoader: FC<{
+    message?: string;
+}>;

package/dist/container/container.d.ts

@@ -0,0 +1,17 @@
+import { Container } from 'inversify';
+export declare const CONTAINER_KEYS: {
+    readonly APP_NAME: symbol;
+    readonly APP_DATABASE_URL: symbol;
+    readonly APP_URL: symbol;
+    readonly APP_SECRET: symbol;
+    readonly APP_CWD: symbol;
+    readonly APP_PUBLIC_DIR: symbol;
+    readonly APP_IS_LOCAL: symbol;
+    readonly APP_IS_DEVELOPMENT: symbol;
+    readonly APP_IS_STAGING: symbol;
+    readonly APP_IS_PRODUCTION: symbol;
+    readonly APP_DEBUG: symbol;
+    readonly APP_ENV: symbol;
+};
+declare const container: Container;
+export { container };

package/dist/functions/asset.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Asset helper function
+ * Generates URLs for static assets from the public directory
+ */
+/**
+ * Set the base path for assets
+ * @param basePath - The base URL path for static assets (e.g., '/static', '/assets')
+ */
+export declare function setAssetBasePath(basePath: string): void;
+/**
+ * Get the current asset base path
+ */
+export declare function getAssetBasePath(): string;
+/**
+ * Generate a URL for a static asset
+ * @param folder - The folder within the public directory (e.g., 'dist', 'images')
+ * @param filename - The filename (e.g., 'app.js', 'style.css')
+ * @returns The full URL path to the asset
+ *
+ * @example
+ * asset('dist', 'app.js')     // returns '/static/dist/app.js'
+ * asset('dist', 'style.css')  // returns '/static/dist/style.css'
+ * asset('images', 'logo.png') // returns '/static/images/logo.png'
+ */
+export declare function asset(folder: string, filename: string): string;
+/**
+ * Generate a URL for an asset directly in the public root
+ * @param filename - The filename
+ * @returns The full URL path
+ */
+export declare function publicAsset(filename: string): string;

package/dist/functions/config.d.ts

@@ -0,0 +1 @@
+export default function config(): ClassDecorator;

package/dist/functions/controller.d.ts

@@ -0,0 +1,59 @@
+import type { Context, Next } from 'hono';
+export declare const CONTROLLER_METADATA: unique symbol;
+export declare const ROUTES_METADATA: unique symbol;
+export interface RouteDefinition {
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'all';
+    path: string;
+    handlerName: string | symbol;
+    middlewares: MiddlewareHandler[];
+}
+export type MiddlewareHandler = (c: Context, next: Next) => Promise<Response | void> | Response | void;
+/**
+ * @controller decorator
+ * Marks a class as a controller and registers it with the DI container
+ *
+ * @param prefix - The base path for all routes in this controller (e.g., '/users')
+ */
+export declare function controller(prefix?: string): <T extends new (...args: any[]) => any>(constructor: T) => T;
+/**
+ * @get decorator - Handles GET requests
+ * @param path - Route path (e.g., '/:id')
+ * @param middlewares - Optional middleware functions
+ */
+export declare const get: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @post decorator - Handles POST requests
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const post: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @put decorator - Handles PUT requests
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const put: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @patch decorator - Handles PATCH requests
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const patch: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @del decorator - Handles DELETE requests
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const del: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @options decorator - Handles OPTIONS requests
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const options: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;
+/**
+ * @all decorator - Handles all HTTP methods
+ * @param path - Route path
+ * @param middlewares - Optional middleware functions
+ */
+export declare const all: (path?: string, ...middlewares: MiddlewareHandler[]) => MethodDecorator;

package/dist/functions/database.d.ts

@@ -0,0 +1 @@
+export declare function database(): <T extends Function>(constructor: T) => T;

package/dist/functions/env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/inject.d.ts

@@ -0,0 +1 @@
+export default function inject(identifier: string | symbol | Function): ParameterDecorator;

package/dist/functions/render.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Render utilities for server-side React rendering
+ */
+import type { Context } from 'hono';
+import type { FC, ReactElement } from 'react';
+/**
+ * Render a React component to an HTML response
+ * @param c - Hono context
+ * @param Component - React component to render
+ * @param props - Props to pass to the component
+ * @returns HTML response
+ */
+export declare function render<P extends object>(c: Context, Component: FC<P>, props?: P): Response;
+/**
+ * Render a React element directly
+ * @param c - Hono context
+ * @param element - React element to render
+ * @returns HTML response
+ */
+export declare function renderElement(c: Context, element: ReactElement): Response;
+/**
+ * Create a render function bound to a context
+ * Useful for cleaner controller code
+ */
+export declare function createRenderer(c: Context): {
+    render: <P extends object>(Component: FC<P>, props?: P) => Response;
+    renderElement: (element: ReactElement) => Response;
+};

package/dist/functions/repository.d.ts

@@ -0,0 +1 @@
+export declare function repository(): <T extends Function>(constructor: T) => T;

package/dist/functions/service.d.ts

@@ -0,0 +1 @@
+export declare function service(): <T extends Function>(constructor: T) => T;

package/dist/functions/validator.d.ts

@@ -0,0 +1 @@
+export default function validator(): ClassDecorator;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @razvan/backend_framework
+ * A Bun-based backend framework with decorators, dependency injection, and controller registration
+ */
+import 'reflect-metadata';
+export { App, type StaticOptions } from './app/app';
+export { Logger, logger } from './logger/logger';
+export { container, CONTAINER_KEYS } from './container/container';
+export { default as inject } from './functions/inject';
+export { controller, get, post, put, patch, del, options, all, CONTROLLER_METADATA, ROUTES_METADATA, type RouteDefinition, type MiddlewareHandler, } from './functions/controller';
+export { service } from './functions/service';
+export { repository } from './functions/repository';
+export { database } from './functions/database';
+export { default as config } from './functions/config';
+export { default as validator } from './functions/validator';
+export { render, renderElement, createRenderer } from './functions/render';
+export { LayoutView, PageLoader, type LayoutViewProps } from './components/LayoutView';
+export { asset, publicAsset, setAssetBasePath, getAssetBasePath } from './functions/asset';
+export type { Validator } from './types';